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