private void VisitFunctionSignatureNode(Node node, NIType nodeFunctionSignature)
{
var signature = Signatures.GetSignatureForNIType(nodeFunctionSignature);
foreach (var inputPair in signature.Inputs.Zip(node.InputTerminals))
{
SignatureTerminal signatureTerminal = inputPair.Key;
Terminal terminal = inputPair.Value;
if (signatureTerminal.IsPassthrough)
{
MarkFacadeVariableOfTerminalInterrupted(terminal);
}
else
{
// NOTE: this is only correct if we assume that all FunctionalNodes are in normal form;
// that is, they don't take in bounded-lifetime variables without outputting at least
// one variable in the same lifetime.
MarkFacadeVariableOfTerminalInterrupted(terminal);
MarkTrueVariableOfTerminalConsumed(terminal);
}
}
foreach (var outputTerminal in node.OutputTerminals)
{
MarkFacadeVariableOfTerminalLive(outputTerminal);
}
}
public bool VisitFunctionalNode(FunctionalNode functionalNode)
{
functionalNode.InputTerminals.ForEach(ValidateRequiredInputTerminal);
// TODO: for functions with more than one data type parameter, it would be better
// to report TypeNotDetermined on an output only if all inputs that use the same
// type parameter(s) are connected.
if (functionalNode.InputTerminals.All(terminal => terminal.IsConnected))
{
Signature signature = Signatures.GetSignatureForNIType(functionalNode.Signature);
foreach (var outputTerminalPair in functionalNode.OutputTerminals.Zip(signature.Outputs)
.Where(pair => !pair.Value.IsPassthrough))
{
VariableReference outputVariable = outputTerminalPair.Key.GetTrueVariable();
if (outputVariable.TypeVariableReference.IsOrContainsTypeVariable)
{
outputTerminalPair.Key.SetDfirMessage(Messages.TypeNotDetermined);
}
}
}
if (functionalNode.RequiredFeatureToggles.Any(feature => !FeatureToggleSupport.IsFeatureEnabled(feature)))
{
functionalNode.SetDfirMessage(Messages.FeatureNotEnabled);
}
return(true);
}
public bool VisitFunctionalNode(FunctionalNode functionalNode)
{
Signature signature = Signatures.GetSignatureForNIType(functionalNode.Signature);
foreach (var terminalPair in functionalNode.OutputTerminals.Zip(signature.Outputs).Where(pair => !pair.Value.IsPassthrough))
{
CreateLocalAllocationForVariable(terminalPair.Key.GetTrueVariable());
}
return(true);
}
private void CreateTerminalsFromSignature(NIType functionSignature)
{
Signature signature = Signatures.GetSignatureForNIType(functionSignature);
foreach (SignatureTerminal signatureTerminal in signature.Inputs)
{
CreateTerminal(Direction.Input, signatureTerminal.DisplayType, signatureTerminal.Name);
}
foreach (SignatureTerminal signatureTerminal in signature.Outputs)
{
CreateTerminal(Direction.Output, signatureTerminal.DisplayType, signatureTerminal.Name);
}
}
private static List <NodeTerminal> CreateNodeTerminalsFromSignature(NIType functionSignature)
{
List <NodeTerminal> terminals = new List <NodeTerminal>();
Signature signature = Signatures.GetSignatureForNIType(functionSignature);
foreach (SignatureTerminal signatureTerminal in signature.Inputs)
{
terminals.Add(new NodeTerminal(Direction.Input, signatureTerminal.DisplayType, signatureTerminal.Name));
}
foreach (SignatureTerminal signatureTerminal in signature.Outputs)
{
terminals.Add(new NodeTerminal(Direction.Output, signatureTerminal.DisplayType, signatureTerminal.Name));
}
return(terminals);
}
private void CreateTerminalsFromSignature(NIType functionSignature)
{
if (functionSignature.IsUnset())
{
throw new ArgumentException("Cannot create terminals from an Unset signature", nameof(functionSignature));
}
Signature signature = Signatures.GetSignatureForNIType(functionSignature);
foreach (SignatureTerminal signatureTerminal in signature.Inputs)
{
CreateTerminal(Direction.Input, signatureTerminal.DisplayType, signatureTerminal.Name);
}
foreach (SignatureTerminal signatureTerminal in signature.Outputs)
{
CreateTerminal(Direction.Output, signatureTerminal.DisplayType, signatureTerminal.Name);
}
}
private void VisitFunctionSignatureNode(Node node, NIType nodeFunctionSignature)
{
node.InputTerminals.ForEach(ValidateRequiredInputTerminal);
// TODO: for functions with more than one data type parameter, it would be better
// to report TypeNotDetermined on an output only if all inputs that use the same
// type parameter(s) are connected.
if (node.InputTerminals.All(terminal => terminal.IsConnected))
{
Signature signature = Signatures.GetSignatureForNIType(nodeFunctionSignature);
foreach (var outputTerminalPair in node.OutputTerminals.Zip(signature.Outputs)
.Where(pair => !pair.Value.IsPassthrough))
{
VariableReference outputVariable = outputTerminalPair.Key.GetTrueVariable();
if (outputVariable.TypeVariableReference.IsOrContainsTypeVariable)
{
outputTerminalPair.Key.SetDfirMessage(Messages.TypeNotDetermined);
}
}
}
}
private void CreateCallForFunctionalNode(LLVMValueRef function, FunctionalNode node)
{
var arguments = new List <LLVMValueRef>();
foreach (Terminal inputTerminal in node.InputTerminals)
{
arguments.Add(GetTerminalValueSource(inputTerminal).GetValue(_builder));
}
Signature nodeSignature = Signatures.GetSignatureForNIType(node.Signature);
foreach (var outputPair in node.OutputTerminals.Zip(nodeSignature.Outputs))
{
if (outputPair.Value.IsPassthrough)
{
continue;
}
var allocationSource = (LocalAllocationValueSource)GetTerminalValueSource(outputPair.Key);
arguments.Add(allocationSource.AllocationPointer);
}
_builder.CreateCall(function, arguments.ToArray(), string.Empty);
}
