private void HandleSqrt(XILSInstr i)
{
FixFormat oformat, rformat;
IsFix(i.OperandTypes[0], out oformat);
IsFix(i.ResultTypes[0], out rformat);
var preds = RemapPreds(i.Preds);
if (oformat == null)
{
Emit(i.Command.CreateStk(preds, i.OperandTypes, i.ResultTypes));
}
else
{
var nrtype = UFix.MakeType((oformat.IntWidth + 2) / 2, rformat.FracWidth);
if (oformat.IntWidth % 2 == 0)
{
var itype = UFix.MakeType(oformat.IntWidth + 1, oformat.FracWidth);
Emit(DefaultInstructionSet.Instance.Convert().CreateStk(preds, 1, i.OperandTypes[0], itype));
Emit(i.Command.CreateStk(1, itype, nrtype));
}
else
{
Emit(i.Command.CreateStk(1, i.OperandTypes[0], nrtype));
}
if (!nrtype.Equals(i.ResultTypes[0]))
{
Emit(DefaultInstructionSet.Instance.Convert().CreateStk(1, nrtype, i.ResultTypes[0]));
}
}
}
/// <summary>
/// Returns a sequence of adminissible result types, given instruction operand types.
/// </summary>
/// <param name="instr">XIL instruction</param>
/// <param name="operandTypes">operand types</param>
/// <returns>admissible result types</returns>
public static IEnumerable <TypeDescriptor> GetDefaultResultTypes(this XILInstr instr, TypeDescriptor[] operandTypes)
{
switch (instr.Name)
{
case InstructionCodes.Abs:
if (operandTypes[0].CILType.Equals(typeof(float)) ||
operandTypes[0].CILType.Equals(typeof(double)) ||
operandTypes[0].CILType.Equals(typeof(int)) ||
operandTypes[0].CILType.Equals(typeof(long)) ||
operandTypes[0].CILType.Equals(typeof(sbyte)) ||
operandTypes[0].CILType.Equals(typeof(short)))
{
yield return(operandTypes[0]);
}
else if (operandTypes[0].CILType.Equals(typeof(double)))
{
yield return(typeof(double));
}
else if (operandTypes[0].CILType.Equals(typeof(SFix)))
{
var fmt = SFix.GetFormat(operandTypes[0]);
var ssample = SFix.FromDouble(0.0, fmt.IntWidth + 1, fmt.FracWidth);
yield return(TypeDescriptor.GetTypeOf(ssample));
var usample = UFix.FromDouble(0.0, fmt.IntWidth, fmt.FracWidth);
yield return(TypeDescriptor.GetTypeOf(usample));
}
else if (operandTypes[0].CILType.Equals(typeof(UFix)))
{
yield return(operandTypes[0]);
}
else
{
throw new NotSupportedException("Operand type not supported");
}
break;
case InstructionCodes.Add:
{
dynamic o1 = operandTypes[0].GetSampleInstance();
dynamic o2 = operandTypes[1].GetSampleInstance();
object r = o1 + o2;
yield return(TypeDescriptor.GetTypeOf(r));
}
break;
case InstructionCodes.And:
{
dynamic o1 = operandTypes[0].GetSampleInstance();
dynamic o2 = operandTypes[1].GetSampleInstance();
object r = o1 & o2;
yield return(TypeDescriptor.GetTypeOf(r));
}
break;
case InstructionCodes.Barrier:
case InstructionCodes.BranchIfFalse:
case InstructionCodes.BranchIfTrue:
yield break;
case InstructionCodes.Ceil:
case InstructionCodes.Floor:
case InstructionCodes.SinCos:
if (operandTypes[0].CILType.Equals(typeof(float)) ||
operandTypes[0].CILType.Equals(typeof(double)))
{
yield return(operandTypes[0]);
}
else
{
throw new NotSupportedException();
}
break;
case InstructionCodes.Cos:
case InstructionCodes.Sin:
if (operandTypes[0].CILType.Equals(typeof(float)) ||
operandTypes[0].CILType.Equals(typeof(double)))
{
yield return(operandTypes[0]);
}
else if (operandTypes[0].CILType.Equals(typeof(UFix)) ||
operandTypes[0].CILType.Equals(typeof(SFix)))
{
var fmt = operandTypes[0].GetFixFormat();
// computation works for at most 26 fractional bits
double xinc = Math.Pow(2.0, Math.Max(-26, -fmt.FracWidth));
double yinc = 1.0 - Math.Cos(xinc);
int fw = -MathExt.FloorLog2(yinc);
// Xilinx Cordic doesn't like more than 48 result bits
if (fw > 48)
{
fw = 48;
}
while (fw >= 0)
{
yield return(SFix.MakeType(2, fw));
--fw;
}
}
else
{
throw new NotSupportedException();
}
break;
case InstructionCodes.ScSin:
case InstructionCodes.ScCos:
case InstructionCodes.ScSinCos:
if (operandTypes[0].CILType.Equals(typeof(float)) ||
operandTypes[0].CILType.Equals(typeof(double)))
{
yield return(operandTypes[0]);
}
else if (operandTypes[0].CILType.Equals(typeof(UFix)) ||
operandTypes[0].CILType.Equals(typeof(SFix)))
{
var fmt = operandTypes[0].GetFixFormat();
// computation works for at most 26 fractional bits
double xinc = Math.Pow(2.0, Math.Max(-26, -fmt.FracWidth));
double yinc = 1.0 - Math.Cos(xinc);
int fw = -MathExt.FloorLog2(yinc);
// Xilinx Cordic doesn't like more than 48 result bits
if (fw > 48)
{
fw = 48;
}
while (fw >= 0)
{
yield return(SFix.MakeType(2, fw));
--fw;
}
}
else
{
throw new NotSupportedException();
}
break;
case InstructionCodes.Sqrt:
if (operandTypes[0].CILType.Equals(typeof(float)) ||
operandTypes[0].CILType.Equals(typeof(double)))
{
yield return(operandTypes[0]);
}
else if (operandTypes[0].CILType.Equals(typeof(UFix)))
{
var fmt = UFix.GetFormat(operandTypes[0]);
int iw = (fmt.IntWidth + 1) / 2;
yield return(UFix.MakeType(iw, fmt.TotalWidth - iw));
}
else if (operandTypes[0].CILType.Equals(typeof(SFix)))
{
var fmt = SFix.GetFormat(operandTypes[0]);
int iw = fmt.IntWidth / 2;
yield return(UFix.MakeType(iw, fmt.TotalWidth - iw - 1));
}
else if (operandTypes[0].CILType.Equals(typeof(Unsigned)))
{
var fmt = UFix.GetFormat(operandTypes[0]);
int iw = (fmt.IntWidth + 1) / 2;
yield return(Unsigned.MakeType(iw));
}
else if (operandTypes[0].CILType.Equals(typeof(Signed)))
{
var fmt = SFix.GetFormat(operandTypes[0]);
int iw = fmt.IntWidth / 2;
yield return(Unsigned.MakeType(iw));
}
else
{
throw new NotImplementedException();
}
break;
case InstructionCodes.Cmp:
throw new NotImplementedException();
case InstructionCodes.Concat:
{
var v1 = (StdLogicVector)operandTypes[0].GetSampleInstance();
var v2 = (StdLogicVector)operandTypes[1].GetSampleInstance();
var c = v1.Concat(v2);
yield return(TypeDescriptor.GetTypeOf(c));
}
break;
case InstructionCodes.Convert:
throw new NotImplementedException();
case InstructionCodes.Dig:
case InstructionCodes.Dup:
case InstructionCodes.Swap:
throw new NotSupportedException();
case InstructionCodes.Div:
{
dynamic o1 = operandTypes[0].GetSampleInstance();
dynamic o2 = operandTypes[1].GetSampleInstance(ETypeCreationOptions.NonZero);
object r = o1 / o2;
yield return(TypeDescriptor.GetTypeOf(r));
}
break;
case InstructionCodes.ExitMarshal:
case InstructionCodes.Goto:
case InstructionCodes.Nop:
case InstructionCodes.Pop:
case InstructionCodes.Return:
case InstructionCodes.StelemFixA:
case InstructionCodes.StelemFixAFixI:
case InstructionCodes.StoreVar:
case InstructionCodes.WrMem:
case InstructionCodes.WrMemFix:
case InstructionCodes.WrPort:
yield break;
case InstructionCodes.Mod2:
{
var fmt = operandTypes[0].GetFixFormat();
if (fmt == null)
{
throw new NotSupportedException("mod2 is only supported for fixed-point types");
}
for (int iw = 2; iw <= fmt.IntWidth; iw++)
{
yield return(new FixFormat(fmt.IsSigned, iw, fmt.FracWidth).ToType());
}
}
break;
case InstructionCodes.DivQF:
case InstructionCodes.ExtendSign:
case InstructionCodes.Ld0:
case InstructionCodes.LdelemFixA:
case InstructionCodes.LdelemFixAFixI:
case InstructionCodes.LdMemBase:
case InstructionCodes.LShift:
case InstructionCodes.RdMem:
case InstructionCodes.RdMemFix:
case InstructionCodes.RShift:
case InstructionCodes.Sign:
case InstructionCodes.SliceFixI:
throw new NotImplementedException();
case InstructionCodes.IsEq:
case InstructionCodes.IsGt:
case InstructionCodes.IsGte:
case InstructionCodes.IsLt:
case InstructionCodes.IsLte:
case InstructionCodes.IsNEq:
yield return(typeof(bool));
break;
case InstructionCodes.LdConst:
yield return(TypeDescriptor.GetTypeOf(instr.Operand));
break;
case InstructionCodes.LoadVar:
{
var lit = (IStorableLiteral)instr.Operand;
yield return(lit.Type);
}
break;
case InstructionCodes.Max:
case InstructionCodes.Min:
yield return(operandTypes[0]);
break;
case InstructionCodes.Mul:
{
dynamic o1 = operandTypes[0].GetSampleInstance();
dynamic o2 = operandTypes[1].GetSampleInstance();
object r = o1 * o2;
yield return(TypeDescriptor.GetTypeOf(r));
}
break;
case InstructionCodes.Neg:
{
dynamic o1 = operandTypes[0].GetSampleInstance();
object r = -o1;
yield return(TypeDescriptor.GetTypeOf(r));
}
break;
case InstructionCodes.Not:
{
dynamic o1 = operandTypes[0].GetSampleInstance();
object r = !o1;
yield return(TypeDescriptor.GetTypeOf(r));
}
break;
case InstructionCodes.Or:
{
dynamic o1 = operandTypes[0].GetSampleInstance();
dynamic o2 = operandTypes[1].GetSampleInstance();
object r = o1 | o2;
yield return(TypeDescriptor.GetTypeOf(r));
}
break;
case InstructionCodes.RdPort:
{
var port = (ISignalOrPortDescriptor)instr.Operand;
yield return(port.ElementType);
}
break;
case InstructionCodes.Rem:
{
dynamic o1 = operandTypes[0].GetSampleInstance();
dynamic o2 = operandTypes[1].GetSampleInstance(ETypeCreationOptions.NonZero);
object r = o1 % o2;
yield return(TypeDescriptor.GetTypeOf(r));
}
break;
case InstructionCodes.Rempow2:
{
dynamic o1 = operandTypes[0].GetSampleInstance();
int n = (int)instr.Operand;
object r = MathExt.Rempow2((dynamic)o1, n);
yield return(TypeDescriptor.GetTypeOf(r));
}
break;
case InstructionCodes.Select:
yield return(operandTypes[1]);
break;
case InstructionCodes.Slice:
yield return(typeof(StdLogicVector));
break;
case InstructionCodes.Sub:
{
dynamic o1 = operandTypes[0].GetSampleInstance();
dynamic o2 = operandTypes[1].GetSampleInstance();
object r = o1 - o2;
yield return(TypeDescriptor.GetTypeOf(r));
}
break;
case InstructionCodes.Xor:
{
dynamic o1 = operandTypes[0].GetSampleInstance();
dynamic o2 = operandTypes[1].GetSampleInstance();
object r = o1 ^ o2;
yield return(TypeDescriptor.GetTypeOf(r));
}
break;
default:
throw new NotImplementedException();
}
}
/// <summary>
/// Returns a type which is able to represent either of two given types without loss of precision
/// </summary>
/// <param name="td1">first given type</param>
/// <param name="td2">second given type</param>
/// <returns></returns>
private static TypeDescriptor GetCommonType(TypeDescriptor td1, TypeDescriptor td2)
{
if (td1.Equals(td2))
{
return(td1);
}
if (IsSFix(td1) && IsUFix(td2))
{
var fmt1 = SFix.GetFormat(td1);
var fmt2 = UFix.GetFormat(td2);
return(SFix.MakeType(
Math.Max(fmt1.IntWidth, fmt2.IntWidth + 1),
Math.Max(fmt1.FracWidth, fmt2.FracWidth)));
}
else if (IsUFix(td1) && IsSFix(td2))
{
return(GetCommonType(td2, td1));
}
else if (IsSFix(td1) && IsSFix(td2))
{
var fmt1 = SFix.GetFormat(td1);
var fmt2 = SFix.GetFormat(td2);
return(SFix.MakeType(
Math.Max(fmt1.IntWidth, fmt2.IntWidth),
Math.Max(fmt1.FracWidth, fmt2.FracWidth)));
}
else if (IsUFix(td1) && IsUFix(td2))
{
var fmt1 = UFix.GetFormat(td1);
var fmt2 = UFix.GetFormat(td2);
return(UFix.MakeType(
Math.Max(fmt1.IntWidth, fmt2.IntWidth),
Math.Max(fmt1.FracWidth, fmt2.FracWidth)));
}
else if (IsSigned(td1))
{
var fmt = SFix.GetFormat(td1);
var td1x = SFix.MakeType(fmt.IntWidth, fmt.FracWidth);
return(GetCommonType(td1x, td2));
}
else if (IsSigned(td2))
{
return(GetCommonType(td2, td1));
}
else if (IsUnsigned(td1))
{
var fmt = UFix.GetFormat(td1);
var td1x = UFix.MakeType(fmt.IntWidth, fmt.FracWidth);
return(GetCommonType(td1x, td2));
}
else if (IsUnsigned(td2))
{
return(GetCommonType(td2, td1));
}
else
{
throw new NotSupportedException(
"Cannot determine common type between " +
td1.ToString() + " and " + td2.ToString());
}
}
private InstructionDependency[] Convert(InstructionDependency[] preds, TypeDescriptor from, TypeDescriptor to)
{
if (from.Equals(to))
{
// nothing to do
return(preds);
}
else if (IsSFix(from) && IsUFix(to))
{
var fromFmt = SFix.GetFormat(from);
var toFmt = UFix.GetFormat(to);
int interIW = toFmt.IntWidth + 1;
int interFW = toFmt.FracWidth;
if (interIW != fromFmt.IntWidth ||
interFW != fromFmt.FracWidth)
{
var interType = SFix.MakeType(interIW, interFW);
Emit(DefaultInstructionSet.Instance.Convert().CreateStk(preds, 1, from, interType));
Emit(DefaultInstructionSet.Instance.Convert().CreateStk(1, interType, to));
}
else
{
Emit(DefaultInstructionSet.Instance.Convert().CreateStk(preds, 1, from, to));
}
return(new InstructionDependency[0]);
}
else if (IsUFix(from) && IsSFix(to))
{
var fromFmt = UFix.GetFormat(from);
var toFmt = SFix.GetFormat(to);
int interIW = toFmt.IntWidth - 1;
int interFW = toFmt.FracWidth;
if (interIW != fromFmt.IntWidth ||
interFW != fromFmt.FracWidth)
{
var interType = UFix.MakeType(interIW, interFW);
Emit(DefaultInstructionSet.Instance.Convert().CreateStk(preds, 1, from, interType));
Emit(DefaultInstructionSet.Instance.Convert().CreateStk(1, interType, to));
}
else
{
Emit(DefaultInstructionSet.Instance.Convert().CreateStk(preds, 1, from, to));
}
return(new InstructionDependency[0]);
}
else if (IsSLV(from))
{
int wfrom = TypeLowering.Instance.GetWireWidth(from);
int wto = TypeLowering.Instance.GetWireWidth(to);
if (wfrom == wto)
{
Emit(DefaultInstructionSet.Instance.Convert().CreateStk(preds, 1, from, to));
}
else
{
var interType = StdLogicVector.MakeType(wto);
Emit(DefaultInstructionSet.Instance.Convert().CreateStk(preds, 1, from, interType));
Convert(interType, to);
}
return(new InstructionDependency[0]);
}
else if (IsSLV(to))
{
int wfrom = TypeLowering.Instance.GetWireWidth(from);
int wto = TypeLowering.Instance.GetWireWidth(to);
if (wfrom == wto)
{
Emit(DefaultInstructionSet.Instance.Convert().CreateStk(preds, 1, from, to));
}
else
{
var interType = StdLogicVector.MakeType(wfrom);
Emit(DefaultInstructionSet.Instance.Convert().CreateStk(preds, 1, from, interType));
Convert(interType, to);
}
return(new InstructionDependency[0]);
}
else
{
Emit(DefaultInstructionSet.Instance.Convert().CreateStk(preds, 1, from, to));
return(new InstructionDependency[0]);
}
}