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(); } }