private void CreateStateValues()
{
string cname = _code.Name;
string ename = "E_" + cname + "_State";
Type tState = CreateEnum(ename, _stateLookup.Count);
_stateType = tState;
TypeDescriptor tdState = (TypeDescriptor)tState;
// do not add type - it will be assigned during post-processing
//_code.Owner.AddChild(tdState, ename);
Array enumValues = tState.GetEnumValues();
foreach (StateInfo si in _stateLookup.Values)
{
int i = si.StateIndex;
si.StateValue = enumValues.GetValue(i);
si.StateExpr.PlaceHolder = LiteralReference.CreateConstant(si.StateValue);
}
ComponentDescriptor owner = (ComponentDescriptor)_code.Owner;
string fname = "m_" + cname + "_State";
var initVal = Activator.CreateInstance(tState);
ISignalOrPortDescriptor sdState = owner.CreateSignalInstance(fname, initVal);
Type tStateSignal = typeof(Signal <>).MakeGenericType(tState);
_tComponent = _modBuilder.DefineType(owner.Instance.GetType().FullName, TypeAttributes.Public);
FieldBuilder fbStateSignal = _tComponent.DefineField(fname, tStateSignal, FieldAttributes.Private);
_stateSignal = new SignalRef(sdState, SignalRef.EReferencedProperty.Instance);
_nextStateSignal.PlaceHolder = new SignalRef(sdState, SignalRef.EReferencedProperty.Next);
}
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();
}
public override bool Rewrite(CodeDescriptor decompilee, MethodBase callee, StackElement[] args, IDecompiler stack, IFunctionBuilder builder)
{
var stateLookup = stack.QueryAttribute <IStateLookup>();
if (stateLookup == null)
{
var pd = decompilee as ProcessDescriptor;
if (pd == null)
{
var md = decompilee as MethodDescriptor;
if (md == null)
{
throw new InvalidOperationException("Unsupported code descriptor: " + decompilee);
}
pd = md.CallingProcess;
}
var pred = pd.Instance.Predicate;
var predElem = stack.GetCallExpression(
pred.Method, new StackElement(LiteralReference.CreateConstant(pred.Target), pred.Target, EVariability.Constant));
var fspec = new FunctionSpec(typeof(void))
{
CILRep = callee,
IntrinsicRep = IntrinsicFunctions.Wait(WaitParams.EWaitKind.WaitUntil)
};
builder.Call(fspec, new Expression[] { predElem.Expr });
}
else
{
builder.Store(
stateLookup.NextStateSignal,
stateLookup.GetStateExpression(stack.CurrentILIndex));
builder.Return();
}
return(true);
}
public ConstSignalSource(object value)
{
_value = value;
Operation = () => _value;
Sensitivity = new EventSource[0];
ValueExpr = LiteralReference.CreateConstant(_value);
}
public override bool Rewrite(CodeDescriptor decompilee, MethodBase callee, StackElement[] args, IDecompiler stack, IFunctionBuilder builder)
{
if (args[0].Variability == Msil.EVariability.ExternVariable)
{
throw new NotSupportedException("Delegate calls must have constant target!");
}
Delegate deleg = (Delegate)args[0].Sample;
if (deleg == null)
{
return(false);
}
StackElement[] callArgs;
if (deleg.Method.IsStatic)
{
callArgs = new StackElement[args.Length - 1];
Array.Copy(args, 1, callArgs, 0, args.Length - 1);
}
else
{
callArgs = new StackElement[args.Length];
Array.Copy(args, callArgs, args.Length);
callArgs[0].Sample = deleg.Target;
callArgs[0].Expr = LiteralReference.CreateConstant(deleg.Target);
callArgs[0].Variability = Msil.EVariability.Constant;
}
stack.ImplementCall(deleg.Method, callArgs);
return(true);
}
private void ImplementFlow(Flow flow, IAlgorithmBuilder pbuilder, SLVSignal cwSignal, HashSet <ISignalOrPortDescriptor> sensitivity)
{
if (FlowMatrix.IsDontCareFlow(flow))
{
int valOffset = _vfc.GetValueWordOffset(flow.Target);
int valWidth = _vfc.GetValueWordWidth(flow.Target);
LiteralReference lrCWValSlice;
if (flow.Target.Desc.ElementType.CILType.Equals(typeof(StdLogic)))
{
lrCWValSlice = new LiteralReference(
((ISignal)cwSignal[valOffset])
.ToSignalRef(SignalRef.EReferencedProperty.Cur));
}
else
{
lrCWValSlice = new LiteralReference(
((ISignal)cwSignal[valOffset + valWidth - 1, valOffset])
.ToSignalRef(SignalRef.EReferencedProperty.Cur));
}
pbuilder.Store(flow.Target, lrCWValSlice);
}
else if (flow is SignalFlow)
{
var sflow = flow as SignalFlow;
pbuilder.Store(flow.Target, sflow.Source);
sensitivity.Add(sflow.Source.Desc);
}
else
{
var vflow = flow as ValueFlow;
pbuilder.Store(vflow.Target,
LiteralReference.CreateConstant(vflow.Value));
}
}
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()
{
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();
}
public Expression TransformTernOp(TernOp expr)
{
if (expr.IsConst())
{
object result = expr.Eval(new DefaultEvaluator());
return(LiteralReference.CreateConstant(result));
}
else
{
return(expr);
}
}
/// <summary>
/// Converts the dimensional specifier to an expression.
/// </summary>
/// <param name="dimSpec">dimensional specifier to convert</param>
/// <returns>expression representing the dimensional specifier</returns>
public static Expression AsExpression(this DimSpec dimSpec)
{
switch (dimSpec.Kind)
{
case DimSpec.EKind.Index:
return(LiteralReference.CreateConstant((int)dimSpec));
case DimSpec.EKind.Range:
return(LiteralReference.CreateConstant((Range)dimSpec));
default: throw new NotImplementedException();
}
}
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 override bool Rewrite(CodeDescriptor decompilee, MethodBase callee, StackElement[] args, IDecompiler stack, IFunctionBuilder builder)
{
if (args[0].Sample == null)
{
throw new InvalidOperationException("null sample");
}
ConstSignalSourceBase src = (ConstSignalSourceBase)callee.Invoke(args[0].Sample);
src.ValueExpr = args[0].Expr;
Expression srcex = LiteralReference.CreateConstant(src);
stack.Push(srcex, src);
return(true);
}
private void CreateCoStateValues()
{
foreach (var kvp in _coFSMs)
{
ITransactionSite target = kvp.Key;
CoFSMInfo cfi = kvp.Value;
string ename, fname;
if (target.Name == null)
{
ename = "E_" + target.Host.Descriptor.Name + "_CoState";
fname = "m_" + target.Host.Descriptor.Name + "_CoState";
}
else
{
ename = "E_" + target.Host.Descriptor.Name + "_" + target.Name + "_CoState";
fname = "m_" + target.Host.Descriptor.Name + "_" + target.Name + "_CoState";
}
Type tState = CreateEnum(ename, cfi.TotalStates);
TypeDescriptor tdState = (TypeDescriptor)tState;
ComponentDescriptor owner = (ComponentDescriptor)_code.Owner;
owner.AddChild(tdState, tdState.Name);
Type tStateSignal = typeof(Signal <>).MakeGenericType(tState);
FieldBuilder fbStateSignal = _tComponent.DefineField(fname, tStateSignal, FieldAttributes.Private);
Array enumValues = tState.GetEnumValues();
object initVal;
if (cfi.HasNeutralTA)
{
initVal = cfi.FirstNeutral.StateValue;
}
else
{
initVal = enumValues.GetValue(0);
}
var sdState = owner.CreateSignalInstance(fname, initVal);
cfi.CoStateSignal = new SignalRef(sdState, SignalRef.EReferencedProperty.Instance);
cfi.CoStateType = tStateSignal;
cfi.NextCoState.PlaceHolder = new SignalRef(sdState, SignalRef.EReferencedProperty.Next);
foreach (CoStateInfo csi in cfi.StateInfos)
{
csi.StateValue = enumValues.GetValue(csi.StateIndex);
csi.StateExpr.PlaceHolder = LiteralReference.CreateConstant(csi.StateValue);
}
}
}
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());
}
}
}
internal void AssembleDecoder(IAlgorithmBuilder pbuilder, SLVSignal cwSignal, HashSet <ISignalOrPortDescriptor> sensitivity)
{
if (_encFlow.NumSymbols == 0)
{
foreach (var target in _targets)
{
pbuilder.Store(target, LiteralReference.CreateConstant(target.Desc.InitialValue));
}
}
else if (_encFlow.NumSymbols == 1)
{
var pflow = _encFlow.BwdEnc[0];
foreach (var flow in pflow.Flows)
{
ImplementFlow(flow, pbuilder, cwSignal, sensitivity);
}
}
else
{
var lrCWSelSlice = new LiteralReference(
((ISignal)cwSignal[SelOffset + SelWidth - 1, SelOffset])
.ToSignalRef(SignalRef.EReferencedProperty.Cur));
pbuilder.Switch(lrCWSelSlice);
for (int i = 0; i < _encFlow.NumSymbols; i++)
{
var selValue = StdLogicVector.FromUInt((uint)i, SelWidth);
var pflow = _encFlow.BwdEnc[i];
if (i + 1 == _encFlow.NumSymbols)
{
pbuilder.DefaultCase();
}
else
{
pbuilder.Case(LiteralReference.CreateConstant(selValue));
}
foreach (var flow in pflow.Flows)
{
ImplementFlow(flow, pbuilder, cwSignal, sensitivity);
}
pbuilder.EndCase();
}
pbuilder.EndSwitch();
}
}
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 Expression TransformLiteralReference(LiteralReference expr)
{
return(base.TransformLiteralReference(expr));
//FIXME: Code below is problematic when ReferencedObject is an array.
//Array will be replaced by its content which is not the intended behavior.
#if false
object constValue;
if (expr.ReferencedObject.IsConst(out constValue))
{
return(LiteralReference.CreateConstant(constValue));
}
else
{
return(base.TransformLiteralReference(expr));
}
#endif
}
public virtual void AssembleStagedDecoderSync(int[] syms, int selWidth,
LiteralReference lrCWSelSlice, IAutoBinder binder, IAlgorithmBuilder pbuilder,
bool registered)
{
if (NumSymbols < 2)
{
return;
}
CreateSelSymbol(binder, registered);
pbuilder.Switch(lrCWSelSlice);
for (int i = 0; i < syms.Length; i++)
{
var selValue = StdLogicVector.FromUInt((uint)i, selWidth);
pbuilder.Case(LiteralReference.CreateConstant(selValue));
int sym = syms[i];
var symbol = _selSymbols.GetValue(sym - 1);
pbuilder.Store(
_symbol.SignalInstance.ToSignalRef(SignalRef.EReferencedProperty.Next),
LiteralReference.CreateConstant(symbol));
pbuilder.EndCase();
}
pbuilder.DefaultCase();
{
pbuilder.Store(
_symbol.SignalInstance.ToSignalRef(SignalRef.EReferencedProperty.Next),
LiteralReference.CreateConstant(StdLogicVector.Xs(NumSymbols)));
}
pbuilder.EndCase();
if (registered)
{
pbuilder.Store(
_symbold.SignalInstance.ToSignalRef(SignalRef.EReferencedProperty.Next),
_symbol.SignalInstance.ToSignalRef(SignalRef.EReferencedProperty.Cur));
}
pbuilder.EndSwitch();
}
public override bool Rewrite(CodeDescriptor decompilee, System.Reflection.MethodBase callee, Analysis.StackElement[] args, Analysis.IDecompiler stack, IFunctionBuilder builder)
{
Array arr = (Array)args[0].Sample;
if (arr == null)
{
throw new InvalidOperationException("Unable to deduce array length");
}
int numElems = arr.Length;
Type tTE = arr.GetType().GetElementType();
Type tTA;
callee.IsFunction(out tTA);
FunctionCall newCall = IntrinsicFunctions.NewArray(tTE, LiteralReference.CreateConstant(numElems), arr);
FunctionSpec fspec = (FunctionSpec)newCall.Callee;
IntrinsicFunction ifun = fspec.IntrinsicRep;
ArrayParams aparams = (ArrayParams)ifun.Parameter;
for (int i = 0; i < numElems; i++)
{
aparams.Elements[i] = IntrinsicFunctions.GetArrayElement(
args[0].Expr,
LiteralReference.CreateConstant(i));
}
object sample = null;
try
{
sample = callee.Invoke(arr);
}
catch (Exception)
{
}
Expression conv = IntrinsicFunctions.Cast(newCall, arr.GetType(), tTA);
stack.Push(conv, sample);
return(true);
}
private void PopulateIndexList(List <Expression[]> result, IndexSpec indexSpec, TypeDescriptor elemType)
{
int count = indexSpec.Indices.Length;
var curSeq = indexSpec.Indices.Reverse();
while (curSeq.Any())
{
var seq = curSeq.Take(elemType.Rank).Reverse();
result.Add(seq
.Select(ds => ds.Kind == DimSpec.EKind.Index ?
LiteralReference.CreateConstant((int)ds) :
LiteralReference.CreateConstant((Range)ds))
.ToArray());
if (seq.Any(ds => ds.Kind == DimSpec.EKind.Range))
{
break;
}
curSeq = curSeq.Skip(elemType.Rank);
elemType = elemType.Element0Type;
}
}
protected override void DeclareAlgorithm()
{
SignalRef curState = new SignalRef(_cfi.CoStateSignal.Desc, SignalRef.EReferencedProperty.Cur);
CaseStatement cs = Switch(curState);
{
for (int i = 0; i < _cfi.TotalStates; i++)
{
CoStateInfo csi = _cfi.StateInfos[i];
object stateValue = csi.StateValue;
Case(LiteralReference.CreateConstant(stateValue));
{
if (csi.DuringAction != null)
{
csi.DuringAction.Implement(this);
}
}
Break(cs);
}
}
EndSwitch();
}
public override bool Rewrite(CodeDescriptor decompilee, MethodBase callee, StackElement[] args, IDecompiler stack, IFunctionBuilder builder)
{
if (args[0].Sample == null)
{
return(false);
}
ISized one, rsample;
if (IsSigned)
{
Signed sample = (Signed)args[0].Sample;
Signed sone = Signed.FromLong(1, (int)sample.Size);
one = sone;
rsample = sample + sone;
}
else
{
Unsigned sample = (Unsigned)args[0].Sample;
Unsigned uone = Unsigned.FromULong(1, (int)sample.Size);
one = uone;
rsample = sample + uone;
}
LiteralReference oneLit = LiteralReference.CreateConstant(one);
Expression inc;
if (IsDecrement)
{
inc = args[0].Expr - oneLit;
}
else
{
inc = args[0].Expr + oneLit;
}
inc.ResultType = TypeDescriptor.GetTypeOf(rsample);
inc = IntrinsicFunctions.Resize(inc, (int)one.Size, TypeDescriptor.GetTypeOf(one));
stack.Push(new StackElement(inc, one, Analysis.Msil.EVariability.ExternVariable));
return(true);
}
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();
}
private static Expression ToExpression(object arg)
{
if (arg is Expression)
{
var ex = (Expression)arg;
if (ex.ResultType.CILType.Equals(typeof(string)))
{
return(ex);
}
else
{
return(IntrinsicFunctions.Cast(ex, ex.ResultType.CILType, typeof(string)));
}
}
else if (arg is ILiteral)
{
return(ToExpression(new LiteralReference((ILiteral)arg)));
}
else
{
return(LiteralReference.CreateConstant(arg.ToString()));
}
}
public override bool Rewrite(Meta.CodeDescriptor decompilee, SysDOM.Expression waitObject, Analysis.IDecompiler stack, SysDOM.IFunctionBuilder builder)
{
var evt = waitObject.ResultType.GetSampleInstance();
var peevent = evt as PredicatedEvent;
if (peevent == null)
{
throw new InvalidOperationException("Unable to resolve awaited PredicatedEvent");
}
var pred = peevent._pred;
var rwc = pred.Method.GetCustomOrInjectedAttribute <RewriteCall>();
if (rwc == null)
{
throw new InvalidOperationException("Awaited predicate is not synthesizable.");
}
var lr = LiteralReference.CreateConstant(pred.Target);
var se = new StackElement(lr, pred.Target, Analysis.Msil.EVariability.Constant);
var pstk = stack.CreatePrivateStack();
if (!rwc.Rewrite(decompilee, pred.Method, new StackElement[] { se }, pstk, builder))
{
throw new InvalidOperationException("Unable to implement awaited predicate.");
}
var predEx = pstk.Pop();
var fspec = new FunctionSpec(typeof(void))
{
IntrinsicRep = IntrinsicFunctions.Wait(WaitParams.EWaitKind.WaitUntil)
};
builder.Call(fspec, predEx.Expr);
return(true);
}
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(Meta.CodeDescriptor decompilee, System.Reflection.MethodBase callee, StackElement[] args, IDecompiler stack, SysDOM.IFunctionBuilder builder)
{
stack.Push(LiteralReference.CreateConstant(false), false);
System.Diagnostics.Debugger.Break();
return(true);
}
public virtual void AssembleStagedDecoderComb(
ValueFlowCoder vfc,
LiteralReference lrCWSelSlice,
IAlgorithmBuilder pbuilder, SLVSignal cwSignal,
HashSet <ISignalOrPortDescriptor> sensitivity,
bool registered)
{
if (NumSymbols == 0)
{
foreach (var target in Targets)
{
pbuilder.Store(target, LiteralReference.CreateConstant(target.Desc.InitialValue));
}
}
else if (NumSymbols == 1)
{
var pflow = BwdEnc[0];
foreach (var flow in pflow.Flows)
{
ImplementFlow(vfc, flow, pbuilder, cwSignal, sensitivity);
}
}
else
{
var symbol = registered ? _symbold : _symbol;
pbuilder.Switch(symbol.SignalInstance.ToSignalRef(SignalRef.EReferencedProperty.Cur));
for (int i = 0; i < NumSymbols; i++)
{
var selValue = _selSymbols.GetValue(i);
var pflow = BwdEnc[i];
pbuilder.Case(LiteralReference.CreateConstant(selValue));
foreach (var flow in pflow.Flows)
{
ImplementFlow(vfc, flow, pbuilder, cwSignal, sensitivity);
}
pbuilder.EndCase();
}
var nulls = StdLogicVector._0s(NumSymbols);
pbuilder.Case(LiteralReference.CreateConstant(nulls));
{
foreach (var target in Targets)
{
int width = Marshal.SerializeForHW(target.Desc.InitialValue).Size;
pbuilder.Store(target,
LiteralReference.CreateConstant(StdLogicVector._0s(width)));
}
}
pbuilder.EndCase();
pbuilder.DefaultCase();
{
foreach (var target in Targets)
{
int width = Marshal.SerializeForHW(target.Desc.InitialValue).Size;
pbuilder.Store(target,
LiteralReference.CreateConstant(StdLogicVector.Xs(width)));
}
}
pbuilder.EndCase();
pbuilder.EndSwitch();
}
}
protected override void DeclareAlgorithm()
{
Dissect();
Initialize();
InitializeCoFSMs();
DecompileStates();
CreateStateValues();
CreateCoStateValues();
SignalRef curState = new SignalRef(_stateSignal.Desc, SignalRef.EReferencedProperty.Cur);
ProcessDescriptor pd = (ProcessDescriptor)_code;
Func <bool> predFunc = pd.Instance.Predicate;
LiteralReference predInstRef = LiteralReference.CreateConstant(predFunc.Target);
StackElement arg = new StackElement(predInstRef, predFunc.Target, EVariability.ExternVariable);
Expression cond = _templ.GetCallExpression(predFunc.Method, arg).Expr;
Expression[] e0 = new Expression[0];
Variable[] v0 = new Variable[0];
If(cond);
{
foreach (var kvp in _coFSMs)
{
CoFSMInfo cfi = kvp.Value;
SignalRef srCor = new SignalRef(cfi.CoStateSignal.Desc, SignalRef.EReferencedProperty.Cur);
Expression lrCo = new LiteralReference(srCor);
CaseStatement csc = Switch(lrCo);
{
for (int i = 0; i < cfi.TotalStates; i++)
{
CoStateInfo csi = cfi.StateInfos[i];
Expression stateValue = LiteralReference.CreateConstant(csi.StateValue);
CoStateInfo csin = csi.Next;
if (csin == null && cfi.HasNeutralTA)
{
csin = cfi.FirstNeutral;
}
Case(stateValue);
{
if (csin != null)
{
ImplementCoStateAction(cfi, csin, this);
}
Break(csc);
}
EndCase();
}
}
EndSwitch();
}
CaseStatement cs = Switch(curState);
{
IEnumerable <StateInfo> states = _stateLookup.Values.OrderBy(si => si.StateIndex);
foreach (StateInfo state in states)
{
Case(state.StateExpr.PlaceHolder);
{
InlineCall(state.StateFun, e0, v0, true);
Break(cs);
}
EndCase();
}
}
EndSwitch();
}
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);
}
