public static INamedTypeSymbol GetTypeByName(TypeDescriptor typeDescriptor, Compilation compilation)
{
//return GetTypeByName(typeDescriptor.TypeName, compilation);
var type = compilation.GetTypeByMetadataName(typeDescriptor.QualifiedMetadataTypeName);
// Another way to access the info
if (type == null)
{
//var references = compilation.References
// .OfType<CompilationReference>()
// .ToDictionary(r => r.Compilation.AssemblyName, r => r.Compilation);
//if (references.ContainsKey(typeDescriptor.AssemblyName))
//{
// compilation = references[typeDescriptor.AssemblyName];
//}
Func <string, bool> pred = s => s.Equals(typeDescriptor.ClassName);
var symbols = compilation.GetSymbolsWithName(pred, SymbolFilter.Type).OfType <INamedTypeSymbol>();
if (symbols.Count() > 0)
{
type = symbols.SingleOrDefault(t => typeDescriptor.Equals(Utils.CreateTypeDescriptor(t)));
}
}
return(type);
}
/// <summary>
/// Emits a XIL-S instruction and assigns an index to it.
/// </summary>
/// <param name="xilsi">instruction to emit</param>
protected virtual void Emit(XILSInstr xilsi)
{
xilsi.Index = NextOutputInstructionIndex;
if (CurInstr != null)
{
xilsi.CILRef = CurInstr.CILRef;
}
int numOperands = xilsi.OperandTypes.Length;
for (int i = numOperands - 1; i >= 0; i--)
{
TypeDescriptor t = _typeStack.Pop();
if (!t.Equals(xilsi.OperandTypes[i]))
{
throw new ArgumentException("Incompatible operand types");
}
}
foreach (TypeDescriptor result in xilsi.ResultTypes)
{
_typeStack.Push(result);
}
OutInstructions.Add(xilsi);
if (xilsi.Name == InstructionCodes.BranchIfFalse ||
xilsi.Name == InstructionCodes.BranchIfTrue ||
xilsi.Name == InstructionCodes.Goto)
{
_curBB.Clear();
}
else
{
_curBB.Add(xilsi);
}
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (value is Type && TypeDescriptor.Equals(destinationType, typeof(string)))
{
return(((Type)value).FullName);
}
return(base.ConvertTo(context, culture, value, destinationType));
}
public IEnumerable <IXILMapping> TryMap(ITransactionSite taSite, XILInstr instr, TypeDescriptor[] operandTypes, TypeDescriptor[] resultTypes)
{
var fu = taSite.Host;
//if (fu != _host)
// yield break;
var taNop = taSite as NopTASite;
if (taNop == null)
{
yield break;
}
switch (instr.Name)
{
case InstructionCodes.Nop:
case InstructionCodes.Barrier:
if (instr.Operand is int)
{
yield return(new NopXILMapping(taNop, (int)instr.Operand));
}
else
{
yield return(new NopXILMapping(taNop, 0));
}
break;
case InstructionCodes.Convert:
if (TypeLowering.Instance.HasWireType(operandTypes[0]) &&
TypeLowering.Instance.HasWireType(resultTypes[0]) &&
!operandTypes[0].CILType.Equals(resultTypes[0].CILType))
{
TypeDescriptor owt = TypeLowering.Instance.GetWireType(operandTypes[0]);
TypeDescriptor rwt = TypeLowering.Instance.GetWireType(resultTypes[0]);
if (!owt.Equals(rwt))
{
yield break;
}
yield return(new IdXILMapping(taNop));
}
else
{
yield break;
}
break;
default:
yield break;
}
}
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{
if (destinationType == null)
{
throw new ArgumentNullException("destinationType");
}
if (TypeDescriptor.Equals(destinationType, typeof(Type)))
{
return(true);
}
return(base.CanConvertTo(context, destinationType));
}
public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
{
if (sourceType == null)
{
throw new ArgumentNullException("sourceType");
}
if (TypeDescriptor.Equals(sourceType, typeof(string)))
{
return(true);
}
return(base.CanConvertFrom(context, sourceType));
}
private void MakeStringArray(Expression[] elements)
{
TypeDescriptor stype = (TypeDescriptor)typeof(string);
for (int i = 0; i < elements.Length; i++)
{
TypeDescriptor rtype = elements[i].ResultType;
if (!rtype.Equals(stype))
{
elements[i] = IntrinsicFunctions.Cast(
elements[i],
rtype.CILType, typeof(string));
}
}
}
public virtual async Task <bool> IsSubtypeAsync(TypeDescriptor typeDescriptor1, TypeDescriptor typeDescriptor2)
{
var result = false;
if (typeDescriptor1.Equals(typeDescriptor2))
{
result = true;
}
else
{
var roslynType1 = RoslynSymbolFactory.GetTypeByName(typeDescriptor1, this.Compilation);
if (roslynType1 == null && typeDescriptor1.AssemblyName != this.Project.AssemblyName)
{
// We assume if T1 <= T2, then the project (compilation) where T1 is declared must know T2 also
var projectProvider = await this.solutionManager.GetProjectCodeProviderAsync(typeDescriptor1.AssemblyName);
result = await projectProvider.IsSubtypeAsync(typeDescriptor1, typeDescriptor2);
}
else
{
var roslynType2 = RoslynSymbolFactory.GetTypeByName(typeDescriptor2, this.Compilation);
if (roslynType2 == null)
{
// We assume if this project (compilation) knows T1 but don't know T2,
// then it cannot be T1 <= T2
result = false;
}
else
{
result = TypeHelper.InheritsByName(roslynType1, roslynType2);
}
}
}
return(result);
}
public IXILMapping TryAllocate(Component host, XILInstr instr, TypeDescriptor[] operandTypes, TypeDescriptor[] resultTypes, IProject proj)
{
switch (instr.Name)
{
case InstructionCodes.Nop:
case InstructionCodes.Barrier:
if (instr.Operand is int)
{
return(new NopXILMapping(new NopTASite(host), (int)instr.Operand));
}
else
{
return(new NopXILMapping(new NopTASite(host), 0));
}
case InstructionCodes.Convert:
if (TypeLowering.Instance.HasWireType(operandTypes[0]) &&
TypeLowering.Instance.HasWireType(resultTypes[0]) &&
!operandTypes[0].CILType.Equals(resultTypes[0].CILType))
{
TypeDescriptor owt = TypeLowering.Instance.GetWireType(operandTypes[0]);
TypeDescriptor rwt = TypeLowering.Instance.GetWireType(resultTypes[0]);
if (!owt.Equals(rwt))
{
return(null);
}
return(new IdXILMapping(new NopTASite(host)));
}
else
{
return(null);
}
default:
return(null);
}
}
public void TestClass()
{
var c2 = new TestClass2();
Assert.AreEqual(
BuildResult(
"!YamlSerializerTest.YamlRepresenterTest%2BTestClass2",
"Items: ",
" Capacity: 0"
),
YamlSerializer.Serialize(c2)
);
c2.Items.Add(new TestClass1());
Assert.AreEqual(
BuildResult(
"!YamlSerializerTest.YamlRepresenterTest%2BTestClass2",
"Items: ",
" Capacity: 4",
" ICollection.Items: ",
" - {}"
),
YamlSerializer.Serialize(c2)
);
c2.Items[0].a = 1;
Assert.AreEqual(
BuildResult(
"!YamlSerializerTest.YamlRepresenterTest%2BTestClass2",
"Items: ",
" Capacity: 4",
" ICollection.Items: ",
" - a: 1"
),
YamlSerializer.Serialize(c2)
);
// Identical values in different numeric types can not be compared
// after being boxed.
Assert.IsTrue((0.0).Equals(0)); // double.Equals(double) converts int to double before comparison
Assert.IsFalse(0.0.Equals((object)0));
Assert.IsFalse(((object)0.0).Equals(0)); // !!
Assert.IsFalse(((object)(float)0.0).Equals(0.0)); // !!
Assert.IsFalse(((object)0.0) == ((object)0)); // !!
Assert.IsFalse(ValueType.Equals((object)0.0, (object)0)); // !!
Assert.IsFalse(ValueType.Equals((object)0.0, (object)(float)0)); // !!
Assert.IsFalse(((ValueType)0.0) == ((ValueType)0)); // !!
Assert.IsFalse(((ValueType)0.0) == ((ValueType)0)); // !!
Assert.IsFalse(Math.Equals((object)0, (object)0.0)); // !!!!
Assert.IsFalse(TypeDescriptor.Equals((object)0.0, (object)0));
// Assert.Throws<ArgumentException>(()=> 0.0.CompareTo( (object)0));
// Assert.Throws<InvalidCastException>(()=> ((double)(object)0).CompareTo((double)(object)(float)0.0));
Assert.IsTrue(0.0 == (double)(int)(object)0);
Assert.IsTrue(0.0 == (double)(decimal)(object)(decimal)0);
Assert.IsTrue(0 == (int)0.0);
Assert.IsFalse(0 == (int)(double)(object)double.NaN); // !!
object nan = double.NaN;
object doubleNan = (double)nan;
// Assert.Throws<InvalidCastException>(() => 0.CompareTo((int)doubleNan)); // !!
Assert.IsFalse(double.NaN == double.NaN);
Assert.IsTrue(typeof(bool).IsPrimitive);
Assert.IsTrue(typeof(bool).IsValueType);
Assert.IsFalse(typeof(bool).IsPointer);
Assert.IsTrue(typeof(bool).IsSubclassOf(typeof(ValueType)));
Assert.IsTrue(typeof(bool).IsSerializable);
Assert.IsFalse(typeof(bool).IsClass);
Assert.IsTrue(typeof(char).IsPrimitive);
Assert.IsTrue(typeof(char).IsValueType);
Assert.IsFalse(typeof(char).IsPointer);
Assert.IsTrue(typeof(char).IsSubclassOf(typeof(ValueType)));
Assert.IsTrue(typeof(char).IsSerializable);
Assert.IsFalse(typeof(char).IsClass);
Assert.IsTrue(typeof(int).IsPrimitive);
Assert.IsTrue(typeof(int).IsValueType);
Assert.IsFalse(typeof(int).IsPointer);
Assert.IsTrue(typeof(int).IsSubclassOf(typeof(ValueType)));
Assert.IsTrue(typeof(int).IsSerializable);
Assert.IsFalse(typeof(int).IsClass);
Assert.IsTrue(typeof(double).IsPrimitive);
Assert.IsTrue(typeof(double).IsValueType);
Assert.IsFalse(typeof(double).IsPointer);
Assert.IsTrue(typeof(double).IsSubclassOf(typeof(ValueType)));
Assert.IsTrue(typeof(double).IsSerializable);
Assert.IsFalse(typeof(double).IsClass);
Assert.IsFalse(typeof(void *).IsPrimitive);
Assert.IsFalse(typeof(void *).IsValueType);
Assert.IsTrue(typeof(void *).IsPointer);
Assert.IsFalse(typeof(void *).IsSubclassOf(typeof(ValueType)));
Assert.IsFalse(typeof(void *).IsSerializable);
Assert.IsTrue(typeof(void *).IsClass);
Assert.IsTrue(typeof(IntPtr).IsPrimitive);
Assert.IsTrue(typeof(IntPtr).IsValueType);
Assert.IsFalse(typeof(IntPtr).IsPointer); // !
Assert.IsTrue(typeof(IntPtr).IsSubclassOf(typeof(ValueType)));
Assert.IsTrue(typeof(IntPtr).IsSerializable); // !
Assert.IsFalse(typeof(IntPtr).IsClass);
Assert.IsFalse(typeof(Test1).IsPrimitive);
Assert.IsTrue(typeof(Test1).IsValueType);
Assert.IsFalse(typeof(Test1).IsPointer);
Assert.IsTrue(typeof(Test1).IsSubclassOf(typeof(ValueType)));
Assert.IsFalse(typeof(Test1).IsSerializable); // !
Assert.IsFalse(typeof(Test1).IsClass);
Assert.IsFalse(typeof(string).IsPrimitive);
Assert.IsFalse(typeof(string).IsValueType);
Assert.IsFalse(typeof(string).IsPointer);
Assert.IsFalse(typeof(string).IsSubclassOf(typeof(ValueType)));
Assert.IsTrue(typeof(string).IsSerializable);
Assert.IsTrue(typeof(string).IsClass);
Assert.IsFalse(typeof(decimal).IsPrimitive);
Assert.IsTrue(typeof(decimal).IsValueType);
Assert.IsFalse(typeof(decimal).IsPointer);
Assert.IsTrue(typeof(decimal).IsSubclassOf(typeof(ValueType)));
Assert.IsTrue(typeof(decimal).IsSerializable);
Assert.IsFalse(typeof(decimal).IsClass);
Assert.IsFalse(typeof(Enum).IsPrimitive);
Assert.IsFalse(typeof(Enum).IsValueType);
Assert.IsFalse(typeof(Enum).IsPointer);
Assert.IsTrue(typeof(Enum).IsSubclassOf(typeof(ValueType)));
Assert.IsTrue(typeof(Enum).IsSerializable);
Assert.IsFalse(typeof(Enum).IsClass);
Assert.IsFalse(typeof(Test2).IsPrimitive);
Assert.IsTrue(typeof(Test2).IsValueType);
Assert.IsFalse(typeof(Test2).IsPointer);
Assert.IsTrue(typeof(Test2).IsSubclassOf(typeof(ValueType)));
Assert.IsTrue(typeof(Test2).IsSerializable);
Assert.IsFalse(typeof(Test2).IsClass);
Assert.IsFalse(typeof(Array).IsPrimitive);
Assert.IsFalse(typeof(Array).IsValueType);
Assert.IsFalse(typeof(Array).IsPointer);
Assert.IsFalse(typeof(Array).IsSubclassOf(typeof(ValueType)));
Assert.IsTrue(typeof(Array).IsSerializable);
Assert.IsTrue(typeof(Array).IsClass);
Assert.IsFalse(typeof(int[]).IsPrimitive);
Assert.IsFalse(typeof(int[]).IsValueType);
Assert.IsFalse(typeof(int[]).IsPointer);
Assert.IsFalse(typeof(int[]).IsSubclassOf(typeof(ValueType)));
Assert.IsTrue(typeof(int[]).IsSerializable);
Assert.IsTrue(typeof(int[]).IsClass);
Assert.IsFalse(typeof(Test3).IsPrimitive);
Assert.IsFalse(typeof(Test3).IsValueType);
Assert.IsFalse(typeof(Test3).IsPointer);
Assert.IsFalse(typeof(Test3).IsSubclassOf(typeof(ValueType)));
Assert.IsFalse(typeof(Test3).IsSerializable);
Assert.IsTrue(typeof(Test3).IsClass);
Assert.IsFalse(typeof(Test4).IsNotPublic);
ShowTypeProperties(typeof(int));
ShowTypeProperties(typeof(IntPtr));
ShowTypeProperties(typeof(void *));
ShowTypeProperties(typeof(decimal));
ShowTypeProperties(typeof(Test1));
ShowTypeProperties(typeof(Enum));
ShowTypeProperties(typeof(Test2));
ShowTypeProperties(typeof(string));
ShowTypeProperties(typeof(Array));
ShowTypeProperties(typeof(int[]));
ShowTypeProperties(typeof(string[]));
ShowTypeProperties(typeof(Test3));
ShowTypeProperties(typeof(Test4));
}
/// <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]);
}
}
private void HandleStelemFixAFixI(XILSInstr xilsi)
{
FixedArrayRef far = (FixedArrayRef)xilsi.StaticOperand;
Array array = far.ArrayObj;
long[] indices = far.Indices;
var preds = RemapPreds(xilsi.Preds);
MemoryMappedStorage mms = GetDataLayout(array);
ArrayMemoryLayout layout = mms.Layout as ArrayMemoryLayout;
if (layout.ElementsPerWord > 1)
{
throw new NotImplementedException("Multiple elements per word not yet implemented");
}
MemoryRegion region = mms.Region;
IMarshalInfo minfo = region.MarshalInfo;
TypeDescriptor elemType = layout.ElementLayout.LayoutedType;
TypeDescriptor rawElemType = TypeDescriptor.GetTypeOf(
StdLogicVector._0s((long)layout.ElementLayout.SizeInBits));
if (!elemType.Equals(rawElemType))
{
Emit(_iset.Convert().CreateStk(1, elemType, rawElemType));
}
uint concatSize = layout.WordsPerElement * minfo.WordSize;
TypeDescriptor concatType = TypeDescriptor.GetTypeOf(
StdLogicVector._0s(concatSize));
if (!concatType.Equals(rawElemType))
{
Emit(_iset.Convert().CreateStk(1, rawElemType, concatType));
}
TypeDescriptor rawWordType = minfo.GetRawWordType();
int shiftSize = MathExt.CeilLog2(concatSize);
if (layout.WordsPerElement > 1)
{
Emit(_iset.Dup().CreateStk(1, concatType, concatType, concatType));
}
Unsigned shift = Unsigned.FromULong(minfo.WordSize, shiftSize);
TypeDescriptor shiftType = TypeDescriptor.GetTypeOf(shift);
TypeDescriptor dwType = minfo.GetRawWordType();
for (uint i = 0; i < layout.WordsPerElement; i++)
{
Unsigned addr = ComputeConstAddress(array, indices, i);
Emit(_iset.LdConst(addr)
.CreateStk(0, TypeDescriptor.GetTypeOf(addr)));
Emit(_iset.WrMem(region)
.CreateStk(preds, 2, dwType, TypeDescriptor.GetTypeOf(addr)));
if (i < layout.WordsPerElement - 1)
{
Emit(_iset.LdConst(shift).CreateStk(0, shiftType));
Emit(_iset.RShift().CreateStk(2, concatType, shiftType, concatType));
if (i + 1 < layout.WordsPerElement - 1)
{
Emit(_iset.Dup().CreateStk(1, concatType, concatType, concatType));
}
}
}
}
private void HandleStelemFixA(XILSInstr xilsi)
{
Array array = (Array)xilsi.StaticOperand;
var preds = RemapPreds(xilsi.Preds);
MemoryMappedStorage mms = GetDataLayout(array);
ArrayMemoryLayout layout = mms.Layout as ArrayMemoryLayout;
if (layout.ElementsPerWord > 1)
{
throw new NotImplementedException("Multiple elements per word not yet implemented");
}
MemoryRegion region = mms.Region;
IMarshalInfo minfo = region.MarshalInfo;
EmitIndexComputation(array);
TypeDescriptor indexType = TypeDescriptor.GetTypeOf(mms.BaseAddress);
TypeDescriptor elemType = layout.ElementLayout.LayoutedType;
Emit(_iset.Swap().CreateStk(2, elemType, indexType, indexType, elemType));
TypeDescriptor rawElemType = TypeDescriptor.GetTypeOf(
StdLogicVector._0s((long)layout.ElementLayout.SizeInBits));
if (!elemType.Equals(rawElemType))
{
Emit(_iset.Convert().CreateStk(1, elemType, rawElemType));
}
uint concatSize = layout.WordsPerElement * minfo.WordSize;
TypeDescriptor concatType = TypeDescriptor.GetTypeOf(
StdLogicVector._0s(concatSize));
if (!concatType.Equals(rawElemType))
{
Emit(_iset.Convert().CreateStk(1, rawElemType, concatType));
}
TypeDescriptor rawWordType = minfo.GetRawWordType();
int shiftSize = MathExt.CeilLog2(concatSize);
if (layout.WordsPerElement > 1)
{
Emit(_iset.Swap().CreateStk(2, indexType, rawElemType, rawElemType, indexType));
Emit(_iset.Dup().CreateStk(1, indexType, indexType, indexType));
Emit(_iset.Dig(2).CreateStk(3, concatType, indexType, indexType, indexType, indexType, concatType));
Emit(_iset.Dup().CreateStk(1, concatType, concatType, concatType));
}
for (uint i = 0; i < layout.WordsPerElement; i++)
{
Emit(_iset.Convert().CreateStk(1, concatType, rawWordType));
if (i < layout.WordsPerElement - 1)
{
Emit(_iset.Dig(2).CreateStk(3, indexType, concatType, rawWordType, concatType, rawWordType, indexType));
}
else
{
Emit(_iset.Swap().CreateStk(2, indexType, rawWordType, rawWordType, indexType));
}
Emit(_iset.WrMem(region).CreateStk(preds, 2, rawWordType, indexType));
if (i < layout.WordsPerElement - 1)
{
Unsigned shift = Unsigned.FromULong(minfo.WordSize, shiftSize);
TypeDescriptor shiftType = TypeDescriptor.GetTypeOf(shift);
Emit(_iset.LdConst(shift).CreateStk(0, shiftType));
Emit(_iset.RShift().CreateStk(2, concatType, shiftType, concatType));
Emit(_iset.Swap().CreateStk(2, indexType, concatType, concatType, indexType));
if (minfo.UseStrongPow2Alignment)
{
if (i + 1 < layout.WordsPerElement)
{
Emit(_iset.Dup().CreateStk(1, indexType, indexType, indexType));
}
Unsigned inc = Unsigned.FromULong(i + 1, region.AddressWidth);
Emit(_iset.Or().CreateStk(2, indexType, indexType, indexType));
if (i + 1 < layout.WordsPerElement)
{
Emit(_iset.Dig(2).CreateStk(1, concatType, indexType, indexType, indexType, indexType, concatType));
Emit(_iset.Swap().CreateStk(2, concatType, indexType, indexType, concatType));
}
}
else
{
Unsigned inc = Unsigned.FromULong(1, region.AddressWidth);
Emit(_iset.LdConst(inc).CreateStk(0, indexType));
Emit(_iset.Add().CreateStk(2, indexType, indexType, indexType));
Emit(_iset.Swap().CreateStk(2, concatType, indexType, indexType, concatType));
}
}
}
}
