public FIRRTL.FirrtlNode GetDefNodeFromLowFirrtlGraph(string nodeName)
{
GraphFIR.Module lowFirMod = LowFirGraph.MainModule;
string[] pathToModule = GetPathToCurrentActualModule();
//Skip first module name as it's the name of the root node
//that we start with
foreach (var pathModName in pathToModule.Skip(1))
{
GraphFIR.FIRRTLNode[] lowModNodes = lowFirMod.GetAllNodes();
GraphFIR.FIRRTLNode childLowModNode = lowModNodes.FirstOrDefault(x => x is GraphFIR.Module mod && mod.Name == pathModName);
if (childLowModNode == null)
{
throw new Exception("High level firrtl module path didn't match low level firrtl module path.");
}
lowFirMod = (GraphFIR.Module)childLowModNode;
}
//This is a meh way of going about getting the correct node.
//Nodes by themselves don't have a name so it works on the assumption
//that there exists an io with the name which points to the correct node.
GraphFIR.IO.FIRIO nodeIO = (GraphFIR.IO.FIRIO)lowFirMod.GetIO(nodeName);
return(nodeIO.Flatten().First().Node.FirDefNode);
}
private static void ConnectIO(VisitHelper helper, GraphFIR.IO.FIRIO from, GraphFIR.IO.FIRIO to, bool isPartial, bool canBeConditional = true)
{
GraphFIR.Module fromMod = from.GetModResideIn();
GraphFIR.Module toMod = to.GetModResideIn();
//If going from inside to outside or outside to outside
//then add condition to that connection if currently in
//conditional module.
GraphFIR.IO.Output condition = null;
if (canBeConditional &&
((fromMod == helper.Mod && toMod != helper.Mod) ||
(fromMod != helper.Mod && toMod != helper.Mod)))
{
condition = helper.Mod.EnableCon;
}
from.ConnectToInput(to, isPartial, false, condition);
//If writing to a memory ports data in high level firrtl, then
//the mask also has to be set to true for the part of the port data
//that was written to.
if (GraphFIR.IO.IOHelper.TryGetParentMemPort(to, out var memPort) &&
memPort.FromHighLevelFIRRTL &&
GraphFIR.IO.IOHelper.IsIOInMaskableMemPortData(to, memPort))
{
var scopeEnableCond = helper.ScopeEnabledCond;
foreach (GraphFIR.IO.Input dataInputWrittenTo in to.Flatten())
{
var dataInputMask = memPort.GetMaskFromDataInput(dataInputWrittenTo);
scopeEnableCond.ConnectToInput(dataInputMask, false, false, scopeEnableCond);
}
}
}
private VisitHelper(GraphFIR.Module mod, CircuitGraph lowFirGraph, Dictionary <string, FIRRTL.DefModule> roots, VisitHelper parentHelper, bool isConditional, VisitHelper rootHelper)
{
this.Mod = mod;
this.LowFirGraph = lowFirGraph;
this.ModuleRoots = roots;
this.ParentHelper = parentHelper;
this.IsConditionalModule = isConditional;
this.RootHelper = rootHelper;
}
private static void CleanupModule(GraphFIR.Module mod)
{
//In a truely stupid move, FIRRTL supports connecting
//Sinks to other sinks. In order to support that case
//a sink can pretend to be a source. It's important
//that they stop pretending after the module graph
//has been made because this hack shouldn't be
//visible outside of graph creation. Everything else
//should still work on the assumption that only
//connections from a source to a sink are possible.
mod.RemoveAllDuplexWires();
if (!mod.IsConditional)
{
GraphFIR.IO.IOHelper.BypassCondConnectionsThroughCondModules(mod);
}
}
public static CircuitGraph GetAsGraph(FIRRTL.Circuit circuit, CircuitGraph graphLowFir = null)
{
VisitHelper helper = new VisitHelper(null, graphLowFir);
foreach (var moduleDef in circuit.Modules)
{
helper.ModuleRoots.Add(moduleDef.Name, moduleDef);
}
FIRRTL.DefModule mainModDef = circuit.Modules.SingleOrDefault(x => x.Name == circuit.Main);
if (mainModDef == null)
{
throw new ChiselDebugException("Circuit does not contain a module with the circuits name.");
}
GraphFIR.Module mainModule = VisitModule(helper, null, mainModDef);
foreach (var mod in mainModule.GetAllNestedNodesOfType <GraphFIR.Module>())
{
CleanupModule(mod);
}
//mainModule.InferType();
//mainModule.FinishConnections();
return(new CircuitGraph(circuit.Main, mainModule));
}
public VisitHelper(GraphFIR.Module mod, CircuitGraph lowFirGraph) : this(mod, lowFirGraph, new Dictionary <string, FIRRTL.DefModule>(), null, false, null)
{
}
private static void VisitStatement(VisitHelper helper, FIRRTL.Statement statement)
{
if (statement is FIRRTL.EmptyStmt)
{
return;
}
else if (statement is FIRRTL.Block block)
{
for (int i = 0; i < block.Statements.Count; i++)
{
VisitStatement(helper, block.Statements[i]);
}
}
else if (statement is FIRRTL.Conditionally conditional)
{
VisitConditional(helper, conditional);
}
else if (statement is FIRRTL.Stop stop)
{
var clock = (GraphFIR.IO.Output)VisitExp(helper, stop.Clk, GraphFIR.IO.IOGender.Male);
var enable = (GraphFIR.IO.Output)VisitExp(helper, stop.Enabled, GraphFIR.IO.IOGender.Male);
var firStop = new GraphFIR.FirStop(clock, enable, stop.Ret, stop);
helper.AddNodeToModule(firStop);
}
else if (statement is FIRRTL.Attach)
{
return;
throw new NotImplementedException();
}
else if (statement is FIRRTL.Print)
{
return;
throw new NotImplementedException();
}
else if (statement is FIRRTL.Verification)
{
return;
throw new NotImplementedException();
}
else if (statement is FIRRTL.Connect connect)
{
VisitConnect(helper, connect.Expr, connect.Loc, false);
}
else if (statement is FIRRTL.PartialConnect parConnected)
{
VisitConnect(helper, parConnected.Expr, parConnected.Loc, true);
}
else if (statement is FIRRTL.IsInvalid)
{
return;
throw new NotImplementedException();
}
else if (statement is FIRRTL.CDefMemory cmem)
{
//If have access to low firrth graph then get memory definition
//from it as it includes all port definitions. This avoids having
//to infer memory port types.
if (helper.HasLowFirGraph())
{
var lowFirMem = (FIRRTL.DefMemory)helper.GetDefNodeFromLowFirrtlGraph(cmem.Name);
VisitStatement(helper, lowFirMem);
//Low level firrtl addresses the ports through the memory but
//high level firrtl directly addreses the ports. Need to
//make the ports directly addresseable which is why this is done.
var lowMem = (GraphFIR.IO.MemoryIO)helper.Mod.GetIO(cmem.Name);
foreach (GraphFIR.IO.MemPort port in lowMem.GetAllPorts())
{
port.FromHighLevelFIRRTL = true;
helper.Mod.AddMemoryPort(port);
}
}
else
{
GraphFIR.IO.FIRIO inputType = VisitTypeAsPassive(helper, FIRRTL.Dir.Input, null, cmem.Type);
var memory = new GraphFIR.Memory(cmem.Name, inputType, cmem.Size, 0, 0, cmem.Ruw, cmem);
helper.AddNodeToModule(memory);
}
}
else if (statement is FIRRTL.CDefMPort memPort)
{
var memory = (GraphFIR.IO.MemoryIO)helper.Mod.GetIO(memPort.Mem);
//Port may already have been created if the memory used the low firrtl
//memory definition which contain all ports that will be used
GraphFIR.IO.MemPort port;
if (memory.TryGetIO(memPort.Name, out var existingPort))
{
port = (GraphFIR.IO.MemPort)existingPort;
}
else
{
port = memPort.Direction switch
{
FIRRTL.MPortDir.MInfer => throw new NotImplementedException(),
FIRRTL.MPortDir.MRead => memory.AddReadPort(memPort.Name),
FIRRTL.MPortDir.MWrite => memory.AddWritePort(memPort.Name),
FIRRTL.MPortDir.MReadWrite => memory.AddReadWritePort(memPort.Name),
var error => throw new Exception($"Unknown memory port type. Type: {error}")
};
port.FromHighLevelFIRRTL = true;
helper.Mod.AddMemoryPort(port);
}
ConnectIO(helper, VisitExp(helper, memPort.Exps[0], GraphFIR.IO.IOGender.Male), port.Address, false);
ConnectIO(helper, VisitExp(helper, memPort.Exps[1], GraphFIR.IO.IOGender.Male), port.Clock, false, false);
ConnectIO(helper, helper.ScopeEnabledCond, port.Enabled, false);
//if port has mask then by default set whole mask to true
if (port.HasMask())
{
GraphFIR.IO.FIRIO mask = port.GetMask();
GraphFIR.IO.Output const1 = (GraphFIR.IO.Output)VisitExp(helper, new FIRRTL.UIntLiteral(0, 1), GraphFIR.IO.IOGender.Male);
foreach (var maskInput in mask.Flatten())
{
ConnectIO(helper, const1, maskInput, false);
}
}
}
else if (statement is FIRRTL.DefWire defWire)
{
GraphFIR.IO.FIRIO inputType = VisitTypeAsPassive(helper, FIRRTL.Dir.Output, null, defWire.Type);
inputType = inputType.ToFlow(GraphFIR.IO.FlowChange.Sink, null);
GraphFIR.Wire wire = new GraphFIR.Wire(defWire.Name, inputType, defWire);
helper.AddNodeToModule(wire);
}
else if (statement is FIRRTL.DefRegister reg)
{
GraphFIR.IO.Output clock = (GraphFIR.IO.Output)VisitExp(helper, reg.Clock, GraphFIR.IO.IOGender.Male);
GraphFIR.IO.Output reset = null;
GraphFIR.IO.FIRIO initValue = null;
if (reg.HasResetAndInit())
{
reset = (GraphFIR.IO.Output)VisitExp(helper, reg.Reset, GraphFIR.IO.IOGender.Male);
initValue = VisitExp(helper, reg.Init, GraphFIR.IO.IOGender.Male);
}
GraphFIR.IO.FIRIO inputType = VisitTypeAsPassive(helper, FIRRTL.Dir.Input, null, reg.Type);
GraphFIR.Register register = new GraphFIR.Register(reg.Name, inputType, clock, reset, initValue, reg);
helper.AddNodeToModule(register);
}
else if (statement is FIRRTL.DefInstance instance)
{
GraphFIR.Module mod = VisitModule(helper, instance.Name, helper.ModuleRoots[instance.Module]);
helper.AddNodeToModule(mod);
}
else if (statement is FIRRTL.DefNode node)
{
var nodeOut = VisitExp(helper, node.Value, GraphFIR.IO.IOGender.Male);
if (node.Value is not FIRRTL.RefLikeExpression)
{
nodeOut.SetName(node.Name);
}
helper.Mod.AddIORename(node.Name, nodeOut);
}
else if (statement is FIRRTL.DefMemory mem)
{
GraphFIR.IO.FIRIO inputType = VisitTypeAsPassive(helper, FIRRTL.Dir.Input, null, mem.Type);
var memory = new GraphFIR.Memory(mem.Name, inputType, mem.Depth, mem.ReadLatency, mem.WriteLatency, mem.Ruw, mem);
foreach (var portName in mem.Readers)
{
memory.AddReadPort(portName);
}
foreach (var portName in mem.Writers)
{
memory.AddWritePort(portName);
}
foreach (var portName in mem.ReadWriters)
{
memory.AddReadWritePort(portName);
}
helper.AddNodeToModule(memory);
}
else
{
throw new NotImplementedException();
}
}
