protected override void DeclareAlgorithm() { var srClk = SignalRef.Create(_taSite._clk, SignalRef.EReferencedProperty.RisingEdge); var lrClk = new LiteralReference(srClk); var srEn = SignalRef.Create(_taSite._en, SignalRef.EReferencedProperty.Cur); var lrEn = new LiteralReference(srEn); var lr1 = LiteralReference.CreateConstant(StdLogic._1); var cond = lrClk & (Expression.Equal(lrEn, lr1)); var srSLV = SignalRef.Create(_taSite._slvSignal, SignalRef.EReferencedProperty.Cur); var lrSLV = new LiteralReference(srSLV); Expression conv; if (_taSite._port.InitialValue.GetType().Equals(typeof(StdLogicVector))) { conv = lrSLV; } else { conv = IntrinsicFunctions.Cast( lrSLV, typeof(StdLogicVector), TypeDescriptor.GetTypeOf(_taSite._port.InitialValue)); } var srNext = SignalRef.Create(_taSite._port, SignalRef.EReferencedProperty.Next); If(cond); { Store(srNext, conv); } EndIf(); }
protected override void DeclareAlgorithm() { SignalRef curStateRef = SignalRef.Create(_cpb._stateSignal, SignalRef.EReferencedProperty.Cur); LiteralReference lrCurState = new LiteralReference(curStateRef); Array stateValues = _cpb._stateSignal.Descriptor.ElementType.CILType.GetEnumValues(); // Insert neutral pre-sets _flowSpec.NeutralFlow.ToProcess().Implement(this); // State-dependent MUX Switch(lrCurState); { for (int cstep = 0; cstep < stateValues.Length; cstep++) { Case(LiteralReference.CreateConstant(stateValues.GetValue(cstep))); { Comment(_flowSpec.GetComment(cstep)); _flowSpec.GetFlow(cstep).ToProcess().Implement(this); } EndCase(); } DefaultCase(); { _flowSpec.NeutralFlow.ToProcess().Implement(this); } EndCase(); } EndSwitch(); }
protected override void DeclareAlgorithm() { Signal <StdLogic> clkInst = _binder.GetSignal <StdLogic>(EPortUsage.Clock, "Clk", null, '0'); SignalRef clkRising = SignalRef.Create(clkInst.Descriptor, SignalRef.EReferencedProperty.RisingEdge); LiteralReference lrClkRising = new LiteralReference(clkRising); SignalRef altFlagP = SignalRef.Create(_taSite._brAltFlagP, SignalRef.EReferencedProperty.Cur); LiteralReference lrAltFlagP = new LiteralReference(altFlagP); SignalRef altFlagN = SignalRef.Create(_taSite._brAltFlagN, SignalRef.EReferencedProperty.Cur); LiteralReference lrAltFlagN = new LiteralReference(altFlagN); SignalRef curState = SignalRef.Create(_taSite._curState, SignalRef.EReferencedProperty.Next); SignalRef incState = SignalRef.Create(_taSite._incState, SignalRef.EReferencedProperty.Cur); LiteralReference lrIncState = new LiteralReference(incState); SignalRef altState = SignalRef.Create(_taSite._altState, SignalRef.EReferencedProperty.Cur); LiteralReference lrAltState = new LiteralReference(altState); LiteralReference vcc = LiteralReference.CreateConstant((StdLogicVector)"1"); LiteralReference gnd = LiteralReference.CreateConstant((StdLogicVector)"0"); If(lrClkRising); { If(Expression.Equal(lrAltFlagP, vcc) | Expression.Equal(lrAltFlagN, gnd)); { Store(curState, altState); } Else(); { Store(curState, incState); } EndIf(); } EndIf(); }
protected override void DeclareAlgorithm() { Signal <StdLogic> clkInst = _icb._binder.GetSignal <StdLogic>(EPortUsage.Clock, "Clk", null, '0'); SignalRef clkRising = SignalRef.Create(clkInst.Descriptor, SignalRef.EReferencedProperty.RisingEdge); LiteralReference lrClkRising = new LiteralReference(clkRising); If(lrClkRising); { for (int i = 0; i < _icb._regsCur.Length; i++) { if (_icb._regsCur[i] == null) { continue; } var slotCurInst = _icb._regsCur[i]; SignalRef slotCur = SignalRef.Create(slotCurInst, SignalRef.EReferencedProperty.Next); var slotNextInst = _icb._regsNext[i]; SignalRef slotNext = SignalRef.Create(slotNextInst, SignalRef.EReferencedProperty.Cur); LiteralReference lrSlotNext = new LiteralReference(slotNext); Store(slotCur, lrSlotNext); } } EndIf(); }
public Interlink(int index) { _index = index; _desc = new SignalBuilder(TypeDescriptor.GetTypeOf(StdLogicVector.Empty), StdLogicVector.Empty); _desc.AddAttribute(_index); _srSrc = SignalRef.Create(_desc, SignalRef.EReferencedProperty.Cur); _srSnk = SignalRef.Create(_desc, SignalRef.EReferencedProperty.Next); }
public override bool Rewrite(CodeDescriptor decompilee, MethodBase callee, StackElement[] args, IDecompiler stack, IFunctionBuilder builder) { IHasSignalBase sink = (IHasSignalBase)args[0].Sample; SignalRef next = SignalRef.Create(sink.Signal, SignalRef.EReferencedProperty.Next); builder.Store(next, args[1].Expr); return(true); }
protected override void DeclareAlgorithm() { var inSrs = _taSite._inSignals.Select(s => SignalRef.Create(s.Descriptor, SignalRef.EReferencedProperty.Cur)); var inLrs = inSrs.Select(s => (Expression) new LiteralReference(s)); var concat = inLrs.Aggregate((e1, e2) => Expression.Concat(e1, e2)); var outSr = SignalRef.Create(_taSite._outSignal.Descriptor, SignalRef.EReferencedProperty.Next); Store(outSr, concat); }
protected override void DeclareAlgorithm() { Signal <StdLogic> clkInst = _cpb._binder.GetSignal <StdLogic>(EPortUsage.Clock, "Clk", null, '0'); SignalRef clkRising = SignalRef.Create(clkInst.Descriptor, SignalRef.EReferencedProperty.RisingEdge); LiteralReference lrClkRising = new LiteralReference(clkRising); If(lrClkRising); { Store(_cpb._rst.ToSignalRef(SignalRef.EReferencedProperty.Next), LiteralReference.CreateConstant(StdLogic._0)); } EndIf(); }
public CommonClockProcess(SignalDescriptor clk) { Contract.Requires <ArgumentNullException>(clk != null); Clk = clk; var frame = new DefaultAlgorithmBuilder(); var srClk = SignalRef.Create(Clk, SignalRef.EReferencedProperty.RisingEdge); var lrClk = new LiteralReference(srClk); frame.If(lrClk); BodyBuilder = frame.BeginSubAlgorithm(); frame.EndIf(); FrameBuilder = frame; }
protected override void DeclareAlgorithm() { BuildFlowMap(); var grouped = _enablingStatesMap.GroupBy(kvp => kvp.Key.Target); SignalRef curStateRef = SignalRef.Create(_cpb._stateSignal, SignalRef.EReferencedProperty.Cur); LiteralReference lrCurState = new LiteralReference(curStateRef); Array stateValues = _cpb._stateSignal.Descriptor.ElementType.CILType.GetEnumValues(); foreach (var group in grouped) { if (group.Count() > 1) { var target = group.Key; Flow elseFlow; if (!_elseFlows.TryGetValue(target, out elseFlow)) { continue; } foreach (var kvp in group) { var whenFlow = kvp.Key; var states = kvp.Value; var cond = Expression.Equal(lrCurState, LiteralReference.CreateConstant(states[0])); for (int i = 1; i < states.Count; i++) { cond = cond | Expression.Equal(lrCurState, LiteralReference.CreateConstant(states[i])); } var conditional = Expression.Conditional( cond, whenFlow.GetRHS(), elseFlow.GetRHS()); Store(target, conditional); } } else { var onlyFlow = group.Single().Key; if (!_elseFlows.ContainsKey(onlyFlow.Target)) { continue; } Store(onlyFlow.Target, onlyFlow.GetRHS()); } } }
protected override void DeclareAlgorithm() { SignalRef curStateRef = SignalRef.Create(_cpb._stateSignal, SignalRef.EReferencedProperty.Cur); LiteralReference lrCurState = new LiteralReference(curStateRef); Array stateValues = _cpb._stateSignal.Descriptor.ElementType.CILType.GetEnumValues(); // Insert neutral pre-sets var npflow = new ParFlow(); foreach (var flow in _flowSpec.NeutralFlow.Flows) { if (_nonTristateTargets.Contains(flow.Target)) { npflow.Add(flow); } } npflow.ToProcess().Implement(this); // State-dependent MUX Switch(lrCurState); { for (int cstep = 0; cstep < stateValues.Length; cstep++) { Case(LiteralReference.CreateConstant(stateValues.GetValue(cstep))); { Comment(_flowSpec.GetComment(cstep)); var pflow = new ParFlow(); foreach (var flow in _flowSpec.GetFlow(cstep).Flows) { if (_nonTristateTargets.Contains(flow.Target)) { pflow.Add(flow); } } pflow.ToProcess().Implement(this); } EndCase(); } DefaultCase(); { npflow.ToProcess().Implement(this); } EndCase(); } EndSwitch(); }
public override bool Rewrite(Meta.CodeDescriptor decompilee, SysDOM.Expression waitObject, Analysis.IDecompiler stack, SysDOM.IFunctionBuilder builder) { var evt = waitObject.ResultType.GetSampleInstance(); var sevent = evt as Event; if (sevent == null) { // This workaround is for the following situation: // Signal s; // await s; // This will actually await the "changed event" which is associated with the signal. However, decompilation // will treat the signal instance as the awaited object and pass a Signal instance instead of the event. // The code will try to restore the Event instance from the Awaiter. Awaiter awaiter = null; try { awaiter = ((object)AwaitableExtensionMethods.GetAwaiter((dynamic)evt)) as Awaiter; } catch { } if (awaiter == null) { throw new InvalidOperationException("Unable to resolve awaited MultiEvent"); } sevent = awaiter._event; } var signal = (SignalBase)sevent.Owner; var signalRef = SignalRef.Create(signal, SignalRef.EReferencedProperty.Instance); var arg = (LiteralReference)signalRef; var fspec = new FunctionSpec(typeof(void)) { IntrinsicRep = IntrinsicFunctions.Wait(WaitParams.EWaitKind.WaitOn) }; builder.Call(fspec, arg); return(true); }
protected override void DeclareAlgorithm() { Signal <StdLogic> clkInst = _icb._host.AutoBinder.GetSignal <StdLogic>(EPortUsage.Clock, "Clk", null, '0'); SignalRef clkRising = SignalRef.Create(clkInst.Descriptor, SignalRef.EReferencedProperty.RisingEdge); LiteralReference lrClkRising = new LiteralReference(clkRising); If(lrClkRising); { for (int i = 0; i < _icb._stageInSignals.Count; i++) { var slotCurInst = _icb._stageOutSignals[i]; SignalRef slotCur = SignalRef.Create(slotCurInst, SignalRef.EReferencedProperty.Next); var slotNextInst = _icb._stageInSignals[i]; SignalRef slotNext = SignalRef.Create(slotNextInst, SignalRef.EReferencedProperty.Cur); LiteralReference lrSlotNext = new LiteralReference(slotNext); Store(slotCur, lrSlotNext); } } EndIf(); }
protected override void DeclareAlgorithm() { SignalRef curState = SignalRef.Create(_taSite._curState, SignalRef.EReferencedProperty.Cur); SignalRef incState = SignalRef.Create(_taSite._incState, SignalRef.EReferencedProperty.Next); LiteralReference lrCurState = new LiteralReference(curState); Array stateValues = _taSite._tState.GetEnumValues(); Switch(lrCurState); { for (int i = 0; i < stateValues.Length; i++) { object curValue = stateValues.GetValue(i); object incValue = stateValues.GetValue((i + 1) % stateValues.Length); Case(LiteralReference.CreateConstant(curValue)); { Store(incState, LiteralReference.CreateConstant(incValue)); } EndCase(); } } EndSwitch(); }
public override bool Rewrite(Meta.CodeDescriptor decompilee, SysDOM.Expression waitObject, Analysis.IDecompiler stack, SysDOM.IFunctionBuilder builder) { var evt = waitObject.ResultType.GetSampleInstance(); var mevent = evt as MultiEvent; if (mevent == null) { throw new InvalidOperationException("Unable to resolve awaited MultiEvent"); } var events = mevent._events.Cast <Event>(); var signals = events.Select(e => (SignalBase)e.Owner); var signalRefs = signals.Select(s => SignalRef.Create(s, SignalRef.EReferencedProperty.Instance)); var args = signalRefs.Select(sr => (LiteralReference)sr).ToArray(); var fspec = new FunctionSpec(typeof(void)) { IntrinsicRep = IntrinsicFunctions.Wait(WaitParams.EWaitKind.WaitOn) }; builder.Call(fspec, args); return(true); }
protected override void DeclareAlgorithm() { var srCur = SignalRef.Create(_taSite._portSignal, SignalRef.EReferencedProperty.Cur); var lrCur = new LiteralReference(srCur); if (_taSite._portSignal.ElementType.CILType.Equals(typeof(StdLogic))) { var index = new IndexSpec((DimSpec)0); var srSLV = new SignalRef( _taSite._slvSignal, SignalRef.EReferencedProperty.Next, index.AsExpressions(), index, true); Store(srSLV, lrCur); } else { var convFn = IntrinsicFunctions.Cast(lrCur, _taSite._portSignal.ElementType.CILType, _taSite._slvSignal.ElementType); var srSLV = SignalRef.Create(_taSite._slvSignal, SignalRef.EReferencedProperty.Next); Store(srSLV, convFn); } }
protected override void DeclareAlgorithm() { var srClk = SignalRef.Create(_taSite._clk, SignalRef.EReferencedProperty.RisingEdge); var lrClk = new LiteralReference(srClk); var srWrEn = _taSite.NeedWriteAccess ? SignalRef.Create(_taSite._wrEn, SignalRef.EReferencedProperty.Cur) : null; var lrWrEn = _taSite.NeedWriteAccess ? new LiteralReference(srWrEn) : null; var srAddr = SignalRef.Create(_taSite._addr, SignalRef.EReferencedProperty.Cur); var lrAddr = new LiteralReference(srAddr); var srDataIn = _taSite.NeedWriteAccess ? SignalRef.Create(_taSite._dataIn, SignalRef.EReferencedProperty.Cur) : null; var lrDataIn = _taSite.NeedWriteAccess ? new LiteralReference(srDataIn) : null; var srDataOut = SignalRef.Create(_taSite._dataOut, SignalRef.EReferencedProperty.Next); var hi = LiteralReference.CreateConstant(StdLogic._1); var addrUType = TypeDescriptor.GetTypeOf(((StdLogicVector)_taSite._addr.InitialValue).UnsignedValue); var uAddr = IntrinsicFunctions.Cast(lrAddr, typeof(StdLogicVector), addrUType); var iAddr = IntrinsicFunctions.Cast(uAddr, addrUType.CILType, typeof(int)); var array = _taSite._array; var lrArray = new LiteralReference(array.ArrayLit); var elemType = array.ElementType; var aref = new ArrayRef(lrArray, elemType, iAddr); var convDataIn = _taSite.NeedWriteAccess ? IntrinsicFunctions.Cast(lrDataIn, typeof(StdLogicVector), elemType) : null; var convAref = IntrinsicFunctions.Cast(aref, elemType.CILType, _taSite._dataOut.ElementType); If(lrClk); { Store(srDataOut, convAref); if (_taSite.NeedWriteAccess) { If(Expression.Equal(lrWrEn, hi)); { Store(aref, convDataIn); } EndIf(); } } EndIf(); }
public override bool Rewrite(CodeDescriptor decompilee, Expression waitObject, IDecompiler stack, IFunctionBuilder builder) { if (stack.HasAttribute <Analysis.M2M.HLS>()) { return(true); } var curps = DesignContext.Instance.CurrentProcess; SLSignal clk = (SLSignal)curps.Sensitivity[0].Owner; SignalRef srEdge; if (curps.Predicate.Equals((Func <bool>)clk.RisingEdge)) { srEdge = SignalRef.Create(clk.Descriptor, SignalRef.EReferencedProperty.RisingEdge); } else { srEdge = SignalRef.Create(clk.Descriptor, SignalRef.EReferencedProperty.FallingEdge); } var lrEdge = new LiteralReference(srEdge); int nwait = 0; var nwaitEx = waitObject.Children[0]; bool nwaitConst = nwaitEx.IsConst(); if (nwaitConst) { nwait = (int)TypeConversions.ConvertValue( nwaitEx.Eval(DefaultEvaluator.DefaultConstEvaluator), typeof(int)); } var fspec = new FunctionSpec(typeof(void)) { IntrinsicRep = IntrinsicFunctions.Wait(WaitParams.EWaitKind.WaitUntil) }; Variable v = null; LiteralReference lrV = null; if (!nwaitConst || nwait > 3) { v = new Variable(typeof(int)) { Name = "_wait_i" + (ictr++) }; builder.DeclareLocal(v); lrV = new LiteralReference(v); builder.Store(v, LiteralReference.CreateConstant((int)0)); var loop = builder.Loop(); builder.If(Expression.Equal(lrV, nwaitEx)); { builder.Break(loop); } builder.EndIf(); } int ncalls = 1; if (nwaitConst && nwait <= 3) { ncalls = nwait; } for (int i = 0; i < ncalls; i++) { builder.Call(fspec, lrEdge); } if (!nwaitConst || nwait > 3) { builder.Store(v, lrV + LiteralReference.CreateConstant((int)1)); builder.EndLoop(); } return(true); }
public void AddAccessor(InlineFieldMapperTransactionSite taSite, bool needRead, bool needWrite) { var srWrEn = needWrite ? SignalRef.Create(taSite._wrEn, SignalRef.EReferencedProperty.Cur) : null; var lrWrEn = needWrite ? new LiteralReference(srWrEn) : null; var srDataIn = needWrite ? SignalRef.Create(taSite._dataIn, SignalRef.EReferencedProperty.Cur) : null; var lrDataIn = needWrite ? new LiteralReference(srDataIn) : null; var srDataOut = needRead ? SignalRef.Create(taSite._dataOut, SignalRef.EReferencedProperty.Next) : null; var hi = LiteralReference.CreateConstant(StdLogic._1); var elemType = taSite._literal.Type; var lrVar = new LiteralReference((Literal)taSite._literal); var convDataIn = needWrite ? IntrinsicFunctions.Cast(lrDataIn, typeof(StdLogicVector), elemType) : null; var convVar = needRead ? IntrinsicFunctions.Cast(lrVar, elemType.CILType, taSite._dataOut.ElementType) : null; bool isBool = taSite._literal.Type.CILType.Equals(typeof(bool)); var lr1 = LiteralReference.CreateConstant((StdLogicVector)"1"); var lr0 = LiteralReference.CreateConstant((StdLogicVector)"0"); if (needWrite) { BodyBuilder.If(Expression.Equal(lrWrEn, hi)); { if (isBool) { BodyBuilder.Store(taSite._literal, Expression.Equal(lrDataIn, lr1)); } else { BodyBuilder.Store(taSite._literal, convDataIn); } var diagOut = taSite.Host as ISupportsDiagnosticOutput; if (diagOut != null && diagOut.EnableDiagnostics) { Expression vref = new LiteralReference(taSite.Literal); var fref = taSite.Literal as FieldRef; var field = fref != null ? fref.FieldDesc : null; if (field != null && field.HasAttribute <ActualTypeAttribute>()) { var atype = field.QueryAttribute <ActualTypeAttribute>(); vref = IntrinsicFunctions.Cast(vref, vref.ResultType.CILType, atype.ActualType, true); } BodyBuilder.ReportLine(taSite.Literal.Name + " changed to ", vref); } } BodyBuilder.EndIf(); } if (needRead) { if (isBool) { BodyBuilder.If(lrVar); { BodyBuilder.If(lrVar); BodyBuilder.Store(srDataOut, lr1); } BodyBuilder.Else(); { BodyBuilder.Store(srDataOut, lr0); } BodyBuilder.EndIf(); } else { BodyBuilder.Store(srDataOut, convVar); } } }
private IEnumerable <SignalArgumentDescriptor> InspectMethod(MethodDescriptor md) { List <Statement> stmts = md.Implementation.Body.GetAtomicStatements(); IEnumerable <StoreStatement> stores = stmts.Select(s => s as StoreStatement).Where(s => s != null); Dictionary <ISignalOrPortDescriptor, SignalArgumentDescriptor> map = new Dictionary <ISignalOrPortDescriptor, SignalArgumentDescriptor>(); int order = md.GetArguments().Count(); foreach (StoreStatement stmt in stores) { SignalRef sref = stmt.Container as SignalRef; if (sref == null) { continue; } if (sref.Desc is SignalArgumentDescriptor) { continue; } SignalArgumentDescriptor sad; if (!map.TryGetValue(sref.Desc, out sad)) { string name = "a_" + sref.Desc.Name; SignalDescriptor sd = sref.Desc as SignalDescriptor; PortDescriptor pd = sref.Desc as PortDescriptor; SignalBase signalInst; if (pd != null) { signalInst = ((SignalDescriptor)pd.BoundSignal).Instance; } else { signalInst = sd.Instance; } ArgumentDescriptor.EArgDirection flowDir; if (pd == null) { flowDir = ArgumentDescriptor.EArgDirection.InOut; } else { switch (pd.Direction) { case EFlowDirection.In: flowDir = ArgumentDescriptor.EArgDirection.In; break; case EFlowDirection.InOut: flowDir = ArgumentDescriptor.EArgDirection.InOut; break; case EFlowDirection.Out: flowDir = ArgumentDescriptor.EArgDirection.Out; break; default: throw new NotImplementedException(); } } sad = new SignalArgumentDescriptor( SignalRef.Create(sref.Desc, SignalRef.EReferencedProperty.Instance), ArgumentDescriptor.EArgDirection.In, flowDir, EVariability.Constant, order++); map[sref.Desc] = sad; } SignalRef srefArg = new SignalRef(sad, sref.Prop, sref.Indices, sref.IndexSample, sref.IsStaticIndex); stmt.Container = srefArg; } foreach (SignalArgumentDescriptor sad in map.Values) { md.AddChild(sad, sad.Argument.Name); } return(map.Values.OrderBy(k => k.Order)); }