VuoCompilerNode.cc

Go to the documentation of this file.

 
#include <sstream>
 
#include "VuoCompilerCodeGenUtilities.hh"
#include "VuoCompilerConstantStringCache.hh"
#include "VuoCompilerException.hh"
#include "VuoCompilerInputDataClass.hh"
#include "VuoCompilerInputEventPort.hh"
#include "VuoCompilerInstanceData.hh"
#include "VuoCompilerIssue.hh"
#include "VuoCompilerNode.hh"
#include "VuoCompilerNodeClass.hh"
#include "VuoCompilerOutputEventPort.hh"
#include "VuoCompilerTriggerPort.hh"
#include "VuoCompilerType.hh"
#include "VuoNode.hh"
#include "VuoNodeClass.hh"
#include "VuoPort.hh"
#include "VuoStringUtilities.hh"
#include "VuoType.hh"
 
 
VuoCompilerNode::VuoCompilerNode(VuoNode *baseNode)
    : VuoBaseDetail<VuoNode>("VuoNode", baseNode)
{
    getBase()->setCompiler(this);
 
    instanceData = NULL;
    VuoCompilerInstanceDataClass *instanceDataClass = getBase()->getNodeClass()->getCompiler()->getInstanceDataClass();
    if (instanceDataClass)
        instanceData = new VuoCompilerInstanceData(instanceDataClass);
 
    graphvizIdentifier = getGraphvizIdentifierPrefix();
 
    constantStrings = NULL;
    indexInOrderedNodes = ULONG_MAX - 1;
}
 
void VuoCompilerNode::setIndexInOrderedNodes(size_t indexInOrderedNodes)
{
    this->indexInOrderedNodes = indexInOrderedNodes;
}
 
size_t VuoCompilerNode::getIndexInOrderedNodes(void)
{
    return indexInOrderedNodes;
}
 
void VuoCompilerNode::setConstantStringCache(VuoCompilerConstantStringCache *constantStrings)
{
    this->constantStrings = constantStrings;
 
    vector<VuoPort *> inputPorts = getBase()->getInputPorts();
    vector<VuoPort *> outputPorts = getBase()->getOutputPorts();
    vector<VuoPort *> ports;
    ports.insert(ports.end(), inputPorts.begin(), inputPorts.end());
    ports.insert(ports.end(), outputPorts.begin(), outputPorts.end());
    for (vector<VuoPort *>::iterator i = ports.begin(); i != ports.end(); ++i)
    {
        VuoCompilerPort *port = static_cast<VuoCompilerPort *>( (*i)->getCompiler() );
        port->setConstantStringCache(constantStrings);
    }
}
 
Value * VuoCompilerNode::generateIdentifierValue(Module *module)
{
    return constantStrings->get(module, getIdentifier());
}
 
Value * VuoCompilerNode::generateSubcompositionIdentifierValue(Module *module, BasicBlock *block, Value *compositionIdentifierValue)
{
    vector<Value *> identifierParts;
    identifierParts.push_back(compositionIdentifierValue);
    identifierParts.push_back(constantStrings->get(module, "/" + getIdentifier()));
    return VuoCompilerCodeGenUtilities::generateStringConcatenation(module, block, identifierParts, *constantStrings);
}
 
Value * VuoCompilerNode::generateGetContext(Module *module, BasicBlock *block, Value *compositionStateValue)
{
    return VuoCompilerCodeGenUtilities::generateGetNodeContext(module, block, compositionStateValue, indexInOrderedNodes);
}
 
void VuoCompilerNode::generateAddMetadata(Module *module, BasicBlock *block, Value *compositionStateValue,
                                          const vector<VuoCompilerType *> &orderedTypes,
                                          Function *compositionCreateContextForNode,
                                          Function *compositionSetPortValueFunction, Function *compositionGetPortValueFunction,
                                          Function *compositionFireTriggerPortEventFunction, Function *compositionReleasePortDataFunction)
{
    Function *subcompositionFunctionSrc = getBase()->getNodeClass()->getCompiler()->getCompositionAddNodeMetadataFunction();
 
    Value *nodeIdentifierValue = generateIdentifierValue(module);
    VuoCompilerCodeGenUtilities::generateAddNodeMetadata(module, block, compositionStateValue, nodeIdentifierValue,
                                                         compositionCreateContextForNode, compositionSetPortValueFunction,
                                                         compositionGetPortValueFunction, compositionFireTriggerPortEventFunction,
                                                         compositionReleasePortDataFunction);
 
    vector<VuoPort *> inputPorts = getBase()->getInputPorts();
    vector<VuoPort *> outputPorts = getBase()->getOutputPorts();
    vector<VuoPort *> ports;
    ports.insert(ports.end(), inputPorts.begin(), inputPorts.end());
    ports.insert(ports.end(), outputPorts.begin(), outputPorts.end());
    for (vector<VuoPort *>::iterator i = ports.begin(); i != ports.end(); ++i)
    {
        VuoCompilerPort *port = static_cast<VuoCompilerPort *>( (*i)->getCompiler() );
 
        Value *portIdentifierValue = constantStrings->get(module, port->getIdentifier());
        Value *portNameValue = constantStrings->get(module, port->getBase()->getClass()->getName());
 
        size_t typeIndex;
        string initialValue;
 
        VuoType *dataType = port->getDataVuoType();
        if (dataType)
        {
            vector<VuoCompilerType *>::const_iterator typeIter = find(orderedTypes.begin(), orderedTypes.end(), dataType->getCompiler());
            typeIndex = typeIter - orderedTypes.begin();
 
            VuoCompilerInputEventPort *inputEventPort = dynamic_cast<VuoCompilerInputEventPort *>(port);
            initialValue = (inputEventPort ? inputEventPort->getData()->getInitialValue() : "");
        }
        else
        {
            typeIndex = orderedTypes.size();
        }
 
        Value *initialValueValue = constantStrings->get(module, initialValue);
 
        VuoCompilerCodeGenUtilities::generateAddPortMetadata(module, block, compositionStateValue, portIdentifierValue,
                                                             portNameValue, typeIndex, initialValueValue);
    }
 
    if (subcompositionFunctionSrc)
    {
        Value *runtimeStateValue = VuoCompilerCodeGenUtilities::generateGetCompositionStateRuntimeState(module, block, compositionStateValue);
        Value *compositionIdentifierValue = VuoCompilerCodeGenUtilities::generateGetCompositionStateCompositionIdentifier(module, block, compositionStateValue);
        Value *subcompositionIdentifierValue = generateSubcompositionIdentifierValue(module, block, compositionIdentifierValue);
        Value *subcompositionStateValue = VuoCompilerCodeGenUtilities::generateCreateCompositionState(module, block, runtimeStateValue, subcompositionIdentifierValue);
 
        Function *subcompositionFunctionDst = VuoCompilerModule::declareFunctionInModule(module, subcompositionFunctionSrc);
        Value *arg = VuoCompilerCodeGenUtilities::convertArgumentToParameterType(subcompositionStateValue, subcompositionFunctionDst, 0, NULL, module, block);
        CallInst::Create(subcompositionFunctionDst, arg, "", block);
 
        VuoCompilerCodeGenUtilities::generateFreeCompositionState(module, block, subcompositionStateValue);
        VuoCompilerCodeGenUtilities::generateFreeCall(module, block, subcompositionIdentifierValue);
    }
}
 
Value * VuoCompilerNode::generateCreateContext(Module *module, BasicBlock *block)
{
    // Create the node context.
 
    bool isSubcomposition = getBase()->getNodeClass()->getCompiler()->isSubcomposition();
    unsigned long publishedOutputPortCount = (isSubcomposition ?
                                                  getBase()->getOutputPorts().size() - VuoNodeClass::unreservedOutputPortStartIndex : 0);
 
    Value * nodeContextValue = VuoCompilerCodeGenUtilities::generateCreateNodeContext(module, block, instanceData, isSubcomposition, publishedOutputPortCount);
 
    // Create each port's context.
 
    vector<VuoPort *> inputPorts = getBase()->getInputPorts();
    vector<VuoPort *> outputPorts = getBase()->getOutputPorts();
    vector<VuoPort *> ports;
    ports.insert(ports.end(), inputPorts.begin(), inputPorts.end());
    ports.insert(ports.end(), outputPorts.begin(), outputPorts.end());
    vector<Value *> portContextValues;
    for (vector<VuoPort *>::iterator i = ports.begin(); i != ports.end(); ++i)
    {
        VuoCompilerPort *port = static_cast<VuoCompilerPort *>( (*i)->getCompiler() );
 
        Value *portContextValue = port->generateCreatePortContext(module, block);
        portContextValues.push_back(portContextValue);
    }
 
    VuoCompilerCodeGenUtilities::generateSetNodeContextPortContexts(module, block, nodeContextValue, portContextValues);
 
    return nodeContextValue;
}
 
void VuoCompilerNode::generateEventFunctionCall(Module *module, Function *function, BasicBlock *&currentBlock,
                                                Value *compositionStateValue)
{
    Function *functionSrc = getBase()->getNodeClass()->getCompiler()->getEventFunction();
 
    Value *nodeContextValue = generateGetContext(module, currentBlock, compositionStateValue);
 
    map<VuoCompilerEventPort *, Value *> portContextForEventPort;
    vector<VuoPort *> inputPorts = getBase()->getInputPorts();
    vector<VuoPort *> outputPorts = getBase()->getOutputPorts();
    vector<VuoPort *> ports;
    ports.insert(ports.end(), inputPorts.begin(), inputPorts.end());
    ports.insert(ports.end(), outputPorts.begin(), outputPorts.end());
    for (vector<VuoPort *>::iterator i = ports.begin(); i != ports.end(); ++i)
    {
        VuoCompilerEventPort *eventPort = dynamic_cast<VuoCompilerEventPort *>((*i)->getCompiler());
        if (eventPort)
            portContextForEventPort[eventPort] = eventPort->generateGetPortContext(module, currentBlock, nodeContextValue);
    }
 
    generateFunctionCall(functionSrc, module, currentBlock, compositionStateValue, nodeContextValue, portContextForEventPort);
 
    // The output port should transmit an event if any non-blocking input port received the event.
    // The output port should not transmit an event if no non-blocking or door input ports received the event.
    // Otherwise, the output port's event transmission is handled by the node class implementation.
 
    vector<VuoPort *> nonBlockingInputPorts;
    vector<VuoPort *> doorInputPorts;
    for (vector<VuoPort *>::iterator i = inputPorts.begin(); i != inputPorts.end(); ++i)
    {
        VuoPortClass::EventBlocking eventBlocking = (*i)->getClass()->getEventBlocking();
        if (eventBlocking == VuoPortClass::EventBlocking_None)
            nonBlockingInputPorts.push_back(*i);
        else if (eventBlocking == VuoPortClass::EventBlocking_Door)
            doorInputPorts.push_back(*i);
    }
 
    Value *eventHitNonBlockingInputPort = generateReceivedEventCondition(module, currentBlock, nodeContextValue, nonBlockingInputPorts,
                                                                         portContextForEventPort);
    Value *transmitForAllOutputPorts = eventHitNonBlockingInputPort;
 
    BasicBlock *handleTransmissionBlock = NULL;
    BasicBlock *nextBlock = NULL;
    if (! doorInputPorts.empty())
    {
        handleTransmissionBlock = BasicBlock::Create(module->getContext(), "handleTransmission", function, 0);
        nextBlock = BasicBlock::Create(module->getContext(), "next", function, 0);
 
        Value *eventHitDoorInputPort = generateReceivedEventCondition(module, currentBlock, nodeContextValue, doorInputPorts,
                                                                      portContextForEventPort);
 
        Value *blockForAllOutputPorts = BinaryOperator::Create(Instruction::And,
                                                               BinaryOperator::CreateNot(eventHitNonBlockingInputPort, "", currentBlock),
                                                               BinaryOperator::CreateNot(eventHitDoorInputPort, "", currentBlock),
                                                               "", currentBlock);
        Value *handleTransmission = BinaryOperator::Create(Instruction::Or, transmitForAllOutputPorts, blockForAllOutputPorts, "", currentBlock);
 
        Constant *zeroValue = ConstantInt::get(transmitForAllOutputPorts->getType(), 0);
        ICmpInst *handleTransmissionComparison = new ICmpInst(*currentBlock, ICmpInst::ICMP_NE, handleTransmission, zeroValue, "");
        BranchInst::Create(handleTransmissionBlock, nextBlock, handleTransmissionComparison, currentBlock);
    }
    else
    {
        handleTransmissionBlock = currentBlock;
    }
 
    for (vector<VuoPort *>::iterator i = outputPorts.begin(); i != outputPorts.end(); ++i)
    {
        VuoCompilerOutputEventPort *eventPort = dynamic_cast<VuoCompilerOutputEventPort *>((*i)->getCompiler());
        if (eventPort)
        {
            Value *portContextValue = portContextForEventPort[eventPort];
            eventPort->generateStoreEvent(module, handleTransmissionBlock, nodeContextValue, transmitForAllOutputPorts, portContextValue);
        }
    }
 
    if (! doorInputPorts.empty())
    {
        BranchInst::Create(nextBlock, handleTransmissionBlock);
        currentBlock = nextBlock;
    }
}
 
void VuoCompilerNode::generateInitFunctionCall(Module *module, BasicBlock *block, Value *compositionStateValue)
{
    Function *functionSrc = getBase()->getNodeClass()->getCompiler()->getInitFunction();
 
    Value *nodeContextValue = generateGetContext(module, block, compositionStateValue);
    CallInst *call = generateFunctionCall(functionSrc, module, block, compositionStateValue, nodeContextValue);
 
    Type *instanceDataType = instanceData->getBase()->getClass()->getCompiler()->getType();
    Value *callCasted = VuoCompilerCodeGenUtilities::generateTypeCast(module, block, call, instanceDataType);
    instanceData->generateStore(module, block, nodeContextValue, callCasted);
 
    // Retain the instance data.
    Value *instanceDataValue = instanceData->generateLoad(module, block, nodeContextValue);
    VuoCompilerCodeGenUtilities::generateRetainCall(module, block, instanceDataValue);
}
 
void VuoCompilerNode::generateFiniFunctionCall(Module *module, BasicBlock *block, Value *compositionStateValue)
{
    Function *functionSrc = getBase()->getNodeClass()->getCompiler()->getFiniFunction();
 
    Value *nodeContextValue = generateGetContext(module, block, compositionStateValue);
    if (functionSrc)
        generateFunctionCall(functionSrc, module, block, compositionStateValue, nodeContextValue);
 
    // Release the instance data.
    Value *instanceDataValue = instanceData->generateLoad(module, block, nodeContextValue);
    VuoCompilerCodeGenUtilities::generateReleaseCall(module, block, instanceDataValue);
}
 
void VuoCompilerNode::generateCallbackStartFunctionCall(Module *module, BasicBlock *block, Value *compositionStateValue)
{
    Function *functionSrc = getBase()->getNodeClass()->getCompiler()->getCallbackStartFunction();
    if (! functionSrc)
        return;
 
    Value *nodeContextValue = generateGetContext(module, block, compositionStateValue);
    generateFunctionCall(functionSrc, module, block, compositionStateValue, nodeContextValue);
}
 
void VuoCompilerNode::generateCallbackUpdateFunctionCall(Module *module, BasicBlock *block, Value *compositionStateValue)
{
    Function *functionSrc = getBase()->getNodeClass()->getCompiler()->getCallbackUpdateFunction();
    if (! functionSrc)
        return;
 
    Value *nodeContextValue = generateGetContext(module, block, compositionStateValue);
    generateFunctionCall(functionSrc, module, block, compositionStateValue, nodeContextValue);
}
 
void VuoCompilerNode::generateCallbackStopFunctionCall(Module *module, BasicBlock *block, Value *compositionStateValue)
{
    Function *functionSrc = getBase()->getNodeClass()->getCompiler()->getCallbackStopFunction();
    if (! functionSrc)
        return;
 
    Value *nodeContextValue = generateGetContext(module, block, compositionStateValue);
    generateFunctionCall(functionSrc, module, block, compositionStateValue, nodeContextValue);
}
 
CallInst * VuoCompilerNode::generateFunctionCall(Function *functionSrc, Module *module, BasicBlock *block,
                                                 Value *compositionStateValue, Value *nodeContextValue,
                                                 const map<VuoCompilerEventPort *, Value *> &portContextForEventPort)
{
    Function *functionDst = VuoCompilerModule::declareFunctionInModule(module, functionSrc);
 
    vector<Value *> args(functionDst->getFunctionType()->getNumParams());
 
    // Set up the argument for the composition state (if a subcomposition).
    Value *subcompositionIdentifierValue = NULL;
    Value *subcompositionStateValue = NULL;
    if (getBase()->getNodeClass()->getCompiler()->isSubcomposition())
    {
        Value *runtimeStateValue = VuoCompilerCodeGenUtilities::generateGetCompositionStateRuntimeState(module, block, compositionStateValue);
        Value *compositionIdentifierValue = VuoCompilerCodeGenUtilities::generateGetCompositionStateCompositionIdentifier(module, block, compositionStateValue);
        subcompositionIdentifierValue = generateSubcompositionIdentifierValue(module, block, compositionIdentifierValue);
        subcompositionStateValue = VuoCompilerCodeGenUtilities::generateCreateCompositionState(module, block, runtimeStateValue, subcompositionIdentifierValue);
        args[0] = VuoCompilerCodeGenUtilities::convertArgumentToParameterType(subcompositionStateValue, functionDst, 0, NULL, module, block);
    }
 
    // Set up the arguments for input ports.
    vector<VuoPort *> inputPorts = getBase()->getInputPorts();
    for (vector<VuoPort *>::iterator i = inputPorts.begin(); i != inputPorts.end(); ++i)
    {
        VuoCompilerInputEventPort *eventPort = dynamic_cast<VuoCompilerInputEventPort *>((*i)->getCompiler());
 
        VuoCompilerInputData *data = eventPort->getData();
        bool isEventArgumentInFunction = isArgumentInFunction(eventPort, functionSrc);
        bool isDataArgumentInFunction = data && isArgumentInFunction(data, functionSrc);
 
        if (isEventArgumentInFunction || isDataArgumentInFunction)
        {
            map<VuoCompilerEventPort *, Value *>::const_iterator iter = portContextForEventPort.find(eventPort);
            Value *portContextValue = (iter != portContextForEventPort.end() ?
                                                   iter->second :
                                                   eventPort->generateGetPortContext(module, block, nodeContextValue));
 
            if (isEventArgumentInFunction)
            {
                size_t index = getArgumentIndexInFunction(eventPort, functionSrc);
                args[index] = eventPort->generateLoadEvent(module, block, nodeContextValue, portContextValue);
            }
 
            if (isDataArgumentInFunction)
            {
                size_t index = getArgumentIndexInFunction(data, functionSrc);
                Value *arg = eventPort->generateLoadData(module, block, nodeContextValue, portContextValue);
                Value *secondArg = NULL;
 
                // If we're calling a node function for a subcomposition, and the parameter is a struct that
                // would normally be passed "byval", instead generate code equivalent to the "byval" semantics:
                // Allocate a stack variable, copy the struct into it, and pass the variable's address as
                // the argument to the node function.
                //
                // This is a workaround for a bug where LLVM would sometimes give the node function body
                // an invalid value for a "byval" struct argument. https://b33p.net/kosada/node/11386
                if (getBase()->getNodeClass()->getCompiler()->isSubcomposition() &&
                        arg->getType()->isStructTy() &&
                        eventPort->getDataVuoType()->getCompiler()->getFunctionParameterAttributes().hasAttrSomewhere(Attribute::ByVal))
                {
                    Value *argAsPointer = VuoCompilerCodeGenUtilities::generatePointerToValue(block, arg);
                    arg = new BitCastInst(argAsPointer, functionSrc->getFunctionType()->getParamType(index), "", block);
                }
                else
                {
                    bool isLoweredToTwoParameters = static_cast<VuoCompilerInputDataClass *>(data->getBase()->getClass()->getCompiler())->isLoweredToTwoParameters();
                    Value **secondArgIfNeeded = (isLoweredToTwoParameters ? &secondArg : NULL);
                    arg = VuoCompilerCodeGenUtilities::convertArgumentToParameterType(arg, functionDst, index, secondArgIfNeeded, module, block);
                    if (!arg)
                    {
                        VUserLog("Warning: Couldn't convert argument for input port '%s' of function %s; not generating call.",
                                 (*i)->getClass()->getName().c_str(),
                                 functionDst->getName().str().c_str());
                        return nullptr;
                    }
                }
 
                args[index] = arg;
                if (secondArg)
                    args[index + 1] = secondArg;
            }
        }
    }
 
    // Set up the arguments for output ports.
    vector<VuoPort *> outputPorts = getBase()->getOutputPorts();
    map<VuoCompilerOutputEventPort *, Value *> outputPortDataVariables;
    map<VuoCompilerOutputEventPort *, AllocaInst *> outputPortEventVariables;
    for (vector<VuoPort *>::iterator i = outputPorts.begin(); i != outputPorts.end(); ++i)
    {
        VuoCompilerOutputEventPort *eventPort = dynamic_cast<VuoCompilerOutputEventPort *>((*i)->getCompiler());
        if (eventPort)
        {
            VuoCompilerOutputData *data = eventPort->getData();
            bool isEventArgumentInFunction = isArgumentInFunction(eventPort, functionSrc);
            bool isDataArgumentInFunction = data && isArgumentInFunction(data, functionSrc);
 
            if (isEventArgumentInFunction)
            {
                size_t index = getArgumentIndexInFunction(eventPort, functionSrc);
                PointerType *eventPointerType = static_cast<PointerType *>( functionDst->getFunctionType()->getParamType(index) );
                AllocaInst *arg = new AllocaInst(eventPointerType->getElementType(), "", block);
                new StoreInst(ConstantInt::get(eventPointerType->getElementType(), 0), arg, block);
                outputPortEventVariables[eventPort] = arg;
                args[index] = arg;
            }
 
            if (isDataArgumentInFunction)
            {
                map<VuoCompilerEventPort *, Value *>::const_iterator iter = portContextForEventPort.find(eventPort);
                Value *portContextValue = (iter != portContextForEventPort.end() ?
                                                       iter->second :
                                                       eventPort->generateGetPortContext(module, block, nodeContextValue));
 
                size_t index = getArgumentIndexInFunction(data, functionSrc);
                Type *type = eventPort->getDataVuoType()->getCompiler()->getType();
                Value *dataVariable = VuoCompilerCodeGenUtilities::generateGetPortContextDataVariable(module, block, portContextValue, type);
                outputPortDataVariables[eventPort] = dataVariable;
 
                Value *arg = VuoCompilerCodeGenUtilities::convertArgumentToParameterType(dataVariable, functionDst, index, NULL, module, block);
                if (!arg)
                {
                    VUserLog("Warning: Couldn't convert argument for output port '%s' of function %s; not generating call.",
                             (*i)->getClass()->getName().c_str(),
                             functionDst->getName().str().c_str());
                    return nullptr;
                }
                args[index] = arg;
            }
        }
        else
        {
            VuoCompilerTriggerPort *triggerPort = (VuoCompilerTriggerPort *)((*i)->getCompiler());
            if (isArgumentInFunction(triggerPort, functionSrc))
            {
                size_t index = getArgumentIndexInFunction(triggerPort, functionSrc);
                args[index] = triggerPort->generateLoadFunction(module, block, nodeContextValue);
            }
        }
    }
 
    // Set up the argument for the instance data (if it exists).
    Value *instanceDataVariable = NULL;
    if (instanceData && isArgumentInFunction(instanceData, functionSrc))
    {
        Type *type = instanceData->getBase()->getClass()->getCompiler()->getType();
        instanceDataVariable = VuoCompilerCodeGenUtilities::generateGetNodeContextInstanceDataVariable(module, block, nodeContextValue, type);
 
        size_t index = getArgumentIndexInFunction(instanceData, functionSrc);
        Value *arg = instanceDataVariable;
        args[index] = VuoCompilerCodeGenUtilities::convertArgumentToParameterType(arg, functionDst, index, NULL, module, block);
        if (!args[index])
        {
            VUserLog("Warning: Couldn't convert argument for instance data of function %s; not generating call.", functionDst->getName().str().c_str());
            return nullptr;
        }
    }
 
    // Save the old output port values so they can be released later.
    map<VuoCompilerOutputEventPort *, Value *> oldOutputDataValues;
    for (map<VuoCompilerOutputEventPort *, Value *>::iterator i = outputPortDataVariables.begin(); i != outputPortDataVariables.end(); ++i)
    {
        VuoCompilerOutputEventPort *eventPort = i->first;
        Value *dataVariable = i->second;
 
        oldOutputDataValues[eventPort] = new LoadInst(dataVariable, "", false, block);
    }
 
    // Save the old instance data value so it can be released later.
    Value *oldInstanceDataValue = NULL;
    if (instanceDataVariable)
    {
        oldInstanceDataValue = new LoadInst(instanceDataVariable, "", false, block);
    }
 
    VuoCompilerCodeGenUtilities::generateAddCompositionStateToThreadLocalStorage(module, block, compositionStateValue);
 
    {
        int i = 0;
        for (auto arg : args)
        {
            if (!arg)
            {
                string s;
                raw_string_ostream type(s);
                functionDst->getFunctionType()->getParamType(i)->print(type);
                ostringstream argIndex;
                argIndex << i;
                string details = "When trying to generate a call to function " + functionDst->getName().str() +
                                 ", argument " + argIndex.str() + " (" + type.str() + ") was missing.";
                VuoCompilerIssue issue(VuoCompilerIssue::Error, "compiling composition", "", "", details);
                throw VuoCompilerException(issue);
            }
            ++i;
        }
    }
 
    // Call the node class's function.
    CallInst *call = CallInst::Create(functionDst, args, "", block);
 
    VuoCompilerCodeGenUtilities::generateRemoveCompositionStateFromThreadLocalStorage(module, block);
 
    // Save the output events from temporary variables to the ports.
    // (The temporary variables are needed to avoid mismatched types between the parameters and the arguments, e.g. i8* vs. i64*.)
    for (map<VuoCompilerOutputEventPort *, AllocaInst *>::iterator i = outputPortEventVariables.begin(); i != outputPortEventVariables.end(); ++i)
    {
        VuoCompilerOutputEventPort *eventPort = i->first;
        AllocaInst *eventVariable = i->second;
        Value *eventValue = new LoadInst(eventVariable, "", false, block);
        eventPort->generateStoreEvent(module, block, nodeContextValue, eventValue);
    }
 
    // Retain the new output port values.
    for (map<VuoCompilerOutputEventPort *, Value *>::iterator i = outputPortDataVariables.begin(); i != outputPortDataVariables.end(); ++i)
    {
        VuoCompilerOutputEventPort *eventPort = i->first;
        Value *dataVariable = i->second;
 
        Value *outputDataValue = new LoadInst(dataVariable, "", false, block);
        VuoCompilerType *type = eventPort->getDataVuoType()->getCompiler();
        type->generateRetainCall(module, block, outputDataValue);
    }
 
    // Release the old output port values.
    for (map<VuoCompilerOutputEventPort *, Value *>::iterator i = oldOutputDataValues.begin(); i != oldOutputDataValues.end(); ++i)
    {
        VuoCompilerOutputEventPort *eventPort = i->first;
        Value *oldOutputDataValue = i->second;
 
        VuoCompilerType *type = eventPort->getDataVuoType()->getCompiler();
        type->generateReleaseCall(module, block, oldOutputDataValue);
    }
 
    if (instanceDataVariable)
    {
        // Retain the new instance data value.
        Value *instanceDataValue = new LoadInst(instanceDataVariable, "", false, block);
        VuoCompilerCodeGenUtilities::generateRetainCall(module, block, instanceDataValue);
 
        // Release the old instance data value.
        VuoCompilerCodeGenUtilities::generateReleaseCall(module, block, oldInstanceDataValue);
    }
 
    if (getBase()->getNodeClass()->getCompiler()->isSubcomposition())
    {
        VuoCompilerCodeGenUtilities::generateFreeCompositionState(module, block, subcompositionStateValue);
        VuoCompilerCodeGenUtilities::generateFreeCall(module, block, subcompositionIdentifierValue);
    }
 
    return call;
}
 
bool VuoCompilerNode::isArgumentInFunction(VuoCompilerNodeArgument *argument, Function *function)
{
    VuoCompilerNodeArgumentClass *argumentClass = argument->getBase()->getClass()->getCompiler();
    if (function == getBase()->getNodeClass()->getCompiler()->getEventFunction())
        return argumentClass->isInEventFunction();
    else if (function == getBase()->getNodeClass()->getCompiler()->getInitFunction())
        return argumentClass->isInInitFunction();
    else if (function == getBase()->getNodeClass()->getCompiler()->getCallbackStartFunction())
        return argumentClass->isInCallbackStartFunction();
    else if (function == getBase()->getNodeClass()->getCompiler()->getCallbackUpdateFunction())
        return argumentClass->isInCallbackUpdateFunction();
    else if (function == getBase()->getNodeClass()->getCompiler()->getCallbackStopFunction())
        return argumentClass->isInCallbackStopFunction();
    else if (instanceData == argument &&
             (function == getBase()->getNodeClass()->getCompiler()->getFiniFunction()))
        return true;
    return false;
}
 
size_t VuoCompilerNode::getArgumentIndexInFunction(VuoCompilerNodeArgument *argument, Function *function)
{
    VuoCompilerNodeArgumentClass *argumentClass = argument->getBase()->getClass()->getCompiler();
    if (function == getBase()->getNodeClass()->getCompiler()->getEventFunction())
        return argumentClass->getIndexInEventFunction();
    else if (function == getBase()->getNodeClass()->getCompiler()->getInitFunction())
        return argumentClass->getIndexInInitFunction();
    else if (function == getBase()->getNodeClass()->getCompiler()->getFiniFunction())
        return (getBase()->getNodeClass()->getCompiler()->isSubcomposition() ? 1 : 0);
    else if (function == getBase()->getNodeClass()->getCompiler()->getCallbackStartFunction())
        return argumentClass->getIndexInCallbackStartFunction();
    else if (function == getBase()->getNodeClass()->getCompiler()->getCallbackUpdateFunction())
        return argumentClass->getIndexInCallbackUpdateFunction();
    else if (function == getBase()->getNodeClass()->getCompiler()->getCallbackStopFunction())
        return argumentClass->getIndexInCallbackStopFunction();
    return 0;
}
 
Value * VuoCompilerNode::generateReceivedEventCondition(Module *module, BasicBlock *block, Value *nodeContextValue)
{
    return generateReceivedEventCondition(module, block, nodeContextValue, getBase()->getInputPorts());
}
 
Value * VuoCompilerNode::generateReceivedEventCondition(Module *module, BasicBlock *block, Value *nodeContextValue,
                                                        vector<VuoPort *> selectedInputPorts,
                                                        const map<VuoCompilerEventPort *, Value *> &portContextForEventPort)
{
    Value *conditionValue = ConstantInt::getFalse(block->getContext());
    for (vector<VuoPort *>::iterator i = selectedInputPorts.begin(); i != selectedInputPorts.end(); ++i)
    {
        VuoCompilerInputEventPort *eventPort = dynamic_cast<VuoCompilerInputEventPort *>((*i)->getCompiler());
        if (eventPort)
        {
            map<VuoCompilerEventPort *, Value *>::const_iterator iter = portContextForEventPort.find(eventPort);
            Value *portContextValue = (iter != portContextForEventPort.end() ?
                                                   iter->second :
                                                   eventPort->generateGetPortContext(module, block, nodeContextValue));
 
            Value *pushValue = eventPort->generateLoadEvent(module, block, nodeContextValue, portContextValue);
            conditionValue = BinaryOperator::Create(Instruction::Or, conditionValue, pushValue, "", block);
        }
    }
    return conditionValue;
}
 
VuoCompilerInstanceData * VuoCompilerNode::getInstanceData(void)
{
    return instanceData;
}
 
string VuoCompilerNode::getIdentifier(void)
{
    return getGraphvizIdentifier();
}
 
string VuoCompilerNode::getGraphvizIdentifierPrefix(void)
{
    string titleWithoutSpaces = VuoStringUtilities::convertToCamelCase(getBase()->getTitle(), true, false, false);
 
    if (titleWithoutSpaces.empty())
        return "Node";
    else
        return titleWithoutSpaces;
}
 
void VuoCompilerNode::setGraphvizIdentifier(string graphvizIdentifier)
{
    this->graphvizIdentifier = graphvizIdentifier;
}
 
string VuoCompilerNode::getGraphvizIdentifier(void)
{
    return graphvizIdentifier;
}
 
string VuoCompilerNode::getGraphvizDeclaration(bool shouldPrintPosition, double xPositionOffset, double yPositionOffset,
                                               VuoPort *manuallyFirableInputPort)
{
    ostringstream declaration;
 
    vector<VuoPort *> inputPorts = getBase()->getInputPorts();
    vector<VuoPort *> outputPorts = getBase()->getOutputPorts();
 
    // name
    declaration << getGraphvizIdentifier();
 
    // type
    declaration << " [type=\"" << getBase()->getNodeClass()->getClassName() << "\"";
 
    // version
    declaration << " version=\"" << getBase()->getNodeClass()->getVersion() << "\"";
 
    // label
    declaration << " label=\"" << VuoStringUtilities::transcodeToGraphvizIdentifier(getBase()->getTitle());
    for (vector<VuoPort *>::iterator i = inputPorts.begin(); i != inputPorts.end(); ++i)
    {
        string portName = VuoStringUtilities::transcodeToGraphvizIdentifier((*i)->getClass()->getName());
        declaration << "|<" << portName << ">" << portName << "\\l";
    }
    for (vector<VuoPort *>::iterator i = outputPorts.begin(); i != outputPorts.end(); ++i)
    {
        string portName = VuoStringUtilities::transcodeToGraphvizIdentifier((*i)->getClass()->getName());
        declaration << "|<" << portName << ">" << portName << "\\r";
    }
    declaration << "\"";
 
    // position
    if (shouldPrintPosition)
        declaration << " pos=\"" << getBase()->getX()+xPositionOffset << "," << getBase()->getY()+yPositionOffset << "\"";
 
    // collapsed
    if (getBase()->isCollapsed())
        declaration << " collapsed";
 
    // tint color
    if (getBase()->getTintColor() != VuoNode::TintNone)
        declaration << " fillcolor=\"" << getBase()->getTintColorGraphvizName() << "\"";
 
    // constant values
    for (vector<VuoPort *>::iterator i = inputPorts.begin(); i != inputPorts.end(); ++i)
    {
        VuoPort *port = *i;
        VuoCompilerInputEventPort *eventPort = static_cast<VuoCompilerInputEventPort *>(port->getCompiler());
        VuoCompilerInputData *data = eventPort->getData();
        if (data && (! eventPort->hasConnectedDataCable() && ! data->getInitialValue().empty()))
        {
            string portConstant = data->getInitialValue();
            string escapedPortConstant = VuoStringUtilities::transcodeToGraphvizIdentifier(portConstant);
            declaration << " _" << port->getClass()->getName() << "=\"" << escapedPortConstant << "\"";
        }
    }
 
    // event throttling
    for (vector<VuoPort *>::iterator i = outputPorts.begin(); i != outputPorts.end(); ++i)
    {
        VuoPort *port = *i;
        if (port->getClass()->getPortType() == VuoPortClass::triggerPort)
        {
            string eventThrottling = (port->getEventThrottling() == VuoPortClass::EventThrottling_Enqueue ? "enqueue" : "drop");
            declaration << " _" << port->getClass()->getName() << "_eventThrottling=\"" << eventThrottling << "\"";
        }
    }
 
    // manually firable input port
    if (manuallyFirableInputPort)
        declaration << " _" << manuallyFirableInputPort->getClass()->getName() << "_manuallyFirable";
 
    declaration << "];";
 
    return declaration.str();
}