(string methodName, DkmClrCompilationResultFlags flags) AddMethod(TypeSig type, int index, bool isLocal) {
var methodName = methodNamePrefix + methodNameIndex++.ToString();
var callConv = CallingConvention.Default;
if (sourceMethod.MethodSig.Generic)
callConv |= CallingConvention.Generic;
var methodSig = new MethodSig(callConv, sourceMethod.MethodSig.GenParamCount);
methodSig.RetType = generatedModule.Import(type.RemovePinnedAndModifiers());
if (methodSig.RetType.IsByRef)
methodSig.RetType = methodSig.RetType.Next.RemovePinnedAndModifiers();
if (lastMethodSig != null) {
foreach (var p in lastMethodSig.Params)
methodSig.Params.Add(p);
}
else {
if (sourceMethod.MethodSig.HasThis)
methodSig.Params.Add(generatedModule.Import(sourceMethod.DeclaringType).ToTypeSig());
foreach (var p in sourceMethod.MethodSig.Params)
methodSig.Params.Add(generatedModule.Import(p));
}
const MethodImplAttributes methodImplFlags = MethodImplAttributes.IL | MethodImplAttributes.Managed;
const MethodAttributes methodFlags = MethodAttributes.Assembly | MethodAttributes.Static | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.ReuseSlot;
var method = new MethodDefUser(methodName, methodSig, methodImplFlags, methodFlags);
getLocalsType.Methods.Add(method);
foreach (var gp in sourceMethod.GenericParameters)
method.GenericParameters.Add(Clone(gp));
var body = new CilBody();
method.Body = body;
body.InitLocals = true;
if (sourceMethod.Body is CilBody sourceBody) {
foreach (var l in sourceBody.Variables)
body.Variables.Add(new Local(generatedModule.Import(l.Type), l.Name));
}
body.Instructions.Add(CreateLoadVariable(method, body.Variables, index, isLocal));
if (type.RemovePinnedAndModifiers().GetElementType() == ElementType.ByRef)
body.Instructions.Add(LoadIndirect(type.RemovePinnedAndModifiers()?.Next.RemovePinnedAndModifiers()));
body.Instructions.Add(Instruction.Create(OpCodes.Ret));
lastMethodSig = methodSig;
var flags = DkmClrCompilationResultFlags.None;
if (methodSig.RetType.RemovePinnedAndModifiers().GetElementType() == ElementType.Boolean)
flags |= DkmClrCompilationResultFlags.BoolResult;
return (methodName, flags);
}
TypeDef Resolve(TypeSig type)
{
type = type.RemovePinnedAndModifiers();
if (type is GenericInstSig gis)
{
type = gis.GenericType;
}
var tdrs = type as TypeDefOrRefSig;
if (tdrs == null)
{
return(null);
}
var td = tdrs.TypeDef;
if (td != null)
{
return(td);
}
var tr = tdrs.TypeRef;
if (tr != null)
{
return(tr.Resolve());
}
return(null);
}
public string create(TypeSig typeRef)
{
typeRef = typeRef.RemovePinnedAndModifiers();
if (typeRef == null)
{
return(unknownNameCreator.create());
}
var gis = typeRef as GenericInstSig;
if (gis != null)
{
if (gis.FullName == "System.Nullable`1" &&
gis.GenericArguments.Count == 1 && gis.GenericArguments[0] != null)
{
typeRef = gis.GenericArguments[0];
}
}
string prefix = getPrefix(typeRef);
var elementType = typeRef.ScopeType;
if (elementType == null && isFnPtrSig(typeRef))
{
return(fnPtrNameCreator.create());
}
if (isGenericParam(elementType))
{
return(genericParamNameCreator.create());
}
NameCreator nc;
var typeFullName = typeRef.FullName;
if (typeNames.TryGetValue(typeFullName, out nc))
{
return(nc.create());
}
var fullName = elementType == null ? typeRef.FullName : elementType.FullName;
string shortName;
var dict = prefix == "" ? fullNameToShortName : fullNameToShortNamePrefix;
if (!dict.TryGetValue(fullName, out shortName))
{
fullName = fullName.Replace('/', '.');
int index = fullName.LastIndexOf('.');
shortName = index > 0 ? fullName.Substring(index + 1) : fullName;
index = shortName.LastIndexOf('`');
if (index > 0)
{
shortName = shortName.Substring(0, index);
}
}
return(addTypeName(typeFullName, shortName, prefix).create());
}
public static TypeDef GetType(ModuleDef module, TypeSig type)
{
type = type.RemovePinnedAndModifiers();
var tdr = type as TypeDefOrRefSig;
if (tdr == null)
{
return(null);
}
return(GetType(module, tdr.TypeDefOrRef));
}
public static CachedOutput Create(TypeSig fieldType, TypePrinterFlags flags)
{
fieldType = fieldType.RemovePinnedAndModifiers() ?? fieldType;
if (fieldType is ByRefSig)
{
fieldType = fieldType.Next ?? fieldType;
}
var typeOutput = TypePrinterUtils.Write(new TypeOutput(), fieldType, flags);
return(typeOutput.cachedOutput);
}
public static string ValueToString(object value, TypeSig storageType)
{
var t = storageType.RemovePinnedAndModifiers();
bool addCast = t.GetElementType() == ElementType.Object;
if (t is SZArraySig)
{
addCast = t.Next.RemovePinnedAndModifiers().GetElementType() == ElementType.Object;
}
return(ValueToString(value, addCast));
}
static bool DecodeArrayInitializer(TypeSig elementTypeRef, byte[] initialValue, ILExpression[] output)
{
elementTypeRef = elementTypeRef.RemovePinnedAndModifiers();
TypeCode elementType = TypeAnalysis.GetTypeCode(elementTypeRef);
switch (elementType)
{
case TypeCode.Boolean:
case TypeCode.Byte:
return(DecodeArrayInitializer(initialValue, output, elementType, (d, i) => (int)d[i]));
case TypeCode.SByte:
return(DecodeArrayInitializer(initialValue, output, elementType, (d, i) => (int)unchecked ((sbyte)d[i])));
case TypeCode.Int16:
return(DecodeArrayInitializer(initialValue, output, elementType, (d, i) => (int)BitConverter.ToInt16(d, i)));
case TypeCode.Char:
case TypeCode.UInt16:
return(DecodeArrayInitializer(initialValue, output, elementType, (d, i) => (int)BitConverter.ToUInt16(d, i)));
case TypeCode.Int32:
case TypeCode.UInt32:
return(DecodeArrayInitializer(initialValue, output, elementType, BitConverter.ToInt32));
case TypeCode.Int64:
case TypeCode.UInt64:
return(DecodeArrayInitializer(initialValue, output, elementType, BitConverter.ToInt64));
case TypeCode.Single:
return(DecodeArrayInitializer(initialValue, output, elementType, BitConverter.ToSingle));
case TypeCode.Double:
return(DecodeArrayInitializer(initialValue, output, elementType, BitConverter.ToDouble));
case TypeCode.Object:
var typeDef = elementTypeRef.ToTypeDefOrRef().ResolveWithinSameModule();
if (typeDef != null && typeDef.IsEnum)
{
return(DecodeArrayInitializer(typeDef.GetEnumUnderlyingType(), initialValue, output));
}
return(false);
default:
return(false);
}
}
public static ITypeDefOrRef GetTypeDefOrRef(this TypeSig type)
{
type = type.RemovePinnedAndModifiers();
if (type.IsGenericInstanceType)
{
return(((GenericInstSig)type).GenericType.TypeDefOrRef);
}
else if (type.IsTypeDefOrRef)
{
return(((TypeDefOrRefSig)type).TypeDefOrRef);
}
else
{
return(null);
}
}
bool WriteRefIfByRef(ITextOutput output, TypeSig typeSig, ParamDef pd)
{
if (typeSig.RemovePinnedAndModifiers() is ByRefSig)
{
if (pd != null && (!pd.IsIn && pd.IsOut))
{
output.Write("out", TextTokenKind.Keyword);
output.WriteSpace();
}
else
{
output.Write("ref", TextTokenKind.Keyword);
output.WriteSpace();
}
return(true);
}
return(false);
}
bool WriteRefIfByRef(IDecompilerOutput output, TypeSig typeSig, ParamDef pd)
{
if (typeSig.RemovePinnedAndModifiers() is ByRefSig)
{
if (pd != null && (!pd.IsIn && pd.IsOut))
{
output.Write("out", BoxedTextColor.Keyword);
output.Write(" ", BoxedTextColor.Text);
}
else
{
output.Write("ref", BoxedTextColor.Keyword);
output.Write(" ", BoxedTextColor.Text);
}
return(true);
}
return(false);
}
/// <summary>
/// Gets a type signature color
/// </summary>
/// <param name="typeSig">Type signature</param>
/// <returns></returns>
public virtual object GetColor(TypeSig typeSig)
{
typeSig = typeSig.RemovePinnedAndModifiers();
if (typeSig == null)
{
return(BoxedTextColor.Text);
}
if (typeSig is TypeDefOrRefSig tdr)
{
return(GetColor(tdr.TypeDefOrRef));
}
if (typeSig is GenericSig gsig)
{
return(GetColor(gsig));
}
return(BoxedTextColor.Text);
}
private bool GetClassSize(TypeDef declaringType, TypeSig ts, int ptrSize, out uint size)
{
size = 0;
ts = ts.RemovePinnedAndModifiers();
if (ts == null)
{
return(false);
}
int size2 = ts.ElementType.GetPrimitiveSize(ptrSize);
if (size2 >= 0)
{
size = (uint)size2;
return(true);
}
var tdrs = ts as TypeDefOrRefSig;
if (tdrs == null)
{
return(false);
}
var td = tdrs.TypeDef;
if (td != null)
{
return(TypeDef.GetClassSize(td, out size));
}
var tr = tdrs.TypeRef;
if (tr != null)
{
return(TypeDef.GetClassSize(tr.Resolve(), out size));
}
return(false);
}
public static CachedOutput CreateType(CorValue value, TypeSig ts, IList <CorType> typeArgs, IList <CorType> methodArgs, TypePrinterFlags flags)
{
if (value == null && ts != null)
{
return(TypePrinterUtils.Write(new TypeOutput(), ts, flags, typeArgs, methodArgs).cachedOutput);
}
var valueOutput = CreateType(new TypeOutput(), value, flags);
if (ts == null || value == null)
{
return(valueOutput.cachedOutput);
}
ts = ts.RemovePinnedAndModifiers() ?? ts;
if (ts is ByRefSig)
{
ts = ts.Next ?? ts;
}
var typeOutput = value.WriteType(new TypeOutput(), ts, typeArgs, methodArgs, flags);
return(CreateTypeInternal(valueOutput, typeOutput));
}
/// <summary>
/// Gets a type signature color
/// </summary>
/// <param name="typeSig">Type signature</param>
/// <returns></returns>
public static object GetColor(TypeSig typeSig)
{
typeSig = typeSig.RemovePinnedAndModifiers();
if (typeSig == null)
{
return(BoxedTextColor.Text);
}
var tdr = typeSig as TypeDefOrRefSig;
if (tdr != null)
{
return(GetColor(tdr.TypeDefOrRef));
}
var gsig = typeSig as GenericSig;
if (gsig != null)
{
return(GetColor(gsig));
}
return(BoxedTextColor.Text);
}
public static TextTokenKind GetTextTokenType(TypeSig ts)
{
ts = ts.RemovePinnedAndModifiers();
if (ts == null)
{
return(TextTokenKind.Text);
}
var tdr = ts as TypeDefOrRefSig;
if (tdr != null)
{
return(GetTextTokenType(tdr.TypeDefOrRef));
}
var gsig = ts as GenericSig;
if (gsig != null)
{
return(GetTextTokenType(gsig));
}
return(TextTokenKind.Text);
}
void AddPushDefaultValue(int count, ref int index, TypeSig pushType)
{
pushType = pushType.RemovePinned();
switch (count > 10 ? ElementType.End : pushType.RemovePinnedAndModifiers().GetElementType())
{
case ElementType.Void:
break;
case ElementType.Boolean:
case ElementType.Char:
case ElementType.I1:
case ElementType.U1:
case ElementType.I2:
case ElementType.U2:
case ElementType.I4:
case ElementType.U4:
InstructionsListVM.Insert(index++, CreateInstructionVM(Code.Ldc_I4_0));
break;
case ElementType.I8:
case ElementType.U8:
InstructionsListVM.Insert(index++, CreateInstructionVM(Code.Ldc_I4_0));
InstructionsListVM.Insert(index++, CreateInstructionVM(Code.Conv_I8));
break;
case ElementType.R4:
InstructionsListVM.Insert(index++, CreateInstructionVM(Code.Ldc_R4));
break;
case ElementType.R8:
InstructionsListVM.Insert(index++, CreateInstructionVM(Code.Ldc_R8));
break;
case ElementType.I:
InstructionsListVM.Insert(index++, CreateInstructionVM(Code.Ldc_I4_0));
InstructionsListVM.Insert(index++, CreateInstructionVM(Code.Conv_I));
break;
case ElementType.U:
case ElementType.Ptr:
case ElementType.FnPtr:
InstructionsListVM.Insert(index++, CreateInstructionVM(Code.Ldc_I4_0));
InstructionsListVM.Insert(index++, CreateInstructionVM(Code.Conv_U));
break;
case ElementType.ValueType:
var td = ((ValueTypeSig)pushType).TypeDefOrRef.ResolveTypeDef();
if (td != null && td.IsEnum)
{
var undType = td.GetEnumUnderlyingType().RemovePinnedAndModifiers();
var et = undType.GetElementType();
if ((ElementType.Boolean <= et && et <= ElementType.R8) || et == ElementType.I || et == ElementType.U)
{
AddPushDefaultValue(count + 1, ref index, undType);
break;
}
}
goto case ElementType.TypedByRef;
case ElementType.TypedByRef:
case ElementType.Var:
case ElementType.MVar:
var local = new LocalVM(TypeSigCreatorOptions, new LocalOptions(new Local(pushType)));
this.LocalsListVM.Add(local);
var newInstr = CreateInstructionVM(Code.Ldloca);
newInstr.InstructionOperandVM.OperandListItem = local;
InstructionsListVM.Insert(index++, newInstr);
newInstr = CreateInstructionVM(Code.Initobj);
newInstr.InstructionOperandVM.Other = local.Type.ToTypeDefOrRef();
InstructionsListVM.Insert(index++, newInstr);
newInstr = CreateInstructionVM(Code.Ldloc);
newInstr.InstructionOperandVM.OperandListItem = local;
InstructionsListVM.Insert(index++, newInstr);
break;
case ElementType.GenericInst:
if (((GenericInstSig)pushType).GenericType is ValueTypeSig)
{
goto case ElementType.TypedByRef;
}
goto case ElementType.Class;
case ElementType.End:
case ElementType.String:
case ElementType.ByRef:
case ElementType.Class:
case ElementType.Array:
case ElementType.ValueArray:
case ElementType.R:
case ElementType.Object:
case ElementType.SZArray:
case ElementType.CModReqd:
case ElementType.CModOpt:
case ElementType.Internal:
case ElementType.Module:
case ElementType.Sentinel:
case ElementType.Pinned:
default:
InstructionsListVM.Insert(index++, CreateInstructionVM(Code.Ldnull));
break;
}
}
static ConstantType GetConstantType(TypeSig type, out ITypeDefOrRef enumType)
{
enumType = null;
var t = type.RemovePinnedAndModifiers();
switch (t.GetElementType())
{
case ElementType.Boolean: return(ConstantType.Boolean);
case ElementType.Char: return(ConstantType.Char);
case ElementType.I1: return(ConstantType.SByte);
case ElementType.U1: return(ConstantType.Byte);
case ElementType.I2: return(ConstantType.Int16);
case ElementType.U2: return(ConstantType.UInt16);
case ElementType.I4: return(ConstantType.Int32);
case ElementType.U4: return(ConstantType.UInt32);
case ElementType.I8: return(ConstantType.Int64);
case ElementType.U8: return(ConstantType.UInt64);
case ElementType.R4: return(ConstantType.Single);
case ElementType.R8: return(ConstantType.Double);
case ElementType.String: return(ConstantType.String);
case ElementType.Object: return(ConstantType.Object);
case ElementType.ValueType:
case ElementType.Class:
var tdr = ((ClassOrValueTypeSig)t).TypeDefOrRef;
if (tdr.IsSystemType())
{
return(ConstantType.Type);
}
enumType = tdr;
return(ConstantType.Enum);
case ElementType.SZArray:
var elemType = t.Next.RemovePinnedAndModifiers();
switch (elemType.GetElementType())
{
case ElementType.Boolean: return(ConstantType.BooleanArray);
case ElementType.Char: return(ConstantType.CharArray);
case ElementType.I1: return(ConstantType.SByteArray);
case ElementType.U1: return(ConstantType.ByteArray);
case ElementType.I2: return(ConstantType.Int16Array);
case ElementType.U2: return(ConstantType.UInt16Array);
case ElementType.I4: return(ConstantType.Int32Array);
case ElementType.U4: return(ConstantType.UInt32Array);
case ElementType.I8: return(ConstantType.Int64Array);
case ElementType.U8: return(ConstantType.UInt64Array);
case ElementType.R4: return(ConstantType.SingleArray);
case ElementType.R8: return(ConstantType.DoubleArray);
case ElementType.String: return(ConstantType.StringArray);
case ElementType.Object: return(ConstantType.ObjectArray);
case ElementType.ValueType:
case ElementType.Class:
tdr = ((ClassOrValueTypeSig)elemType).TypeDefOrRef;
if (tdr.IsSystemType())
{
return(ConstantType.TypeArray);
}
enumType = tdr;
return(ConstantType.EnumArray);
}
break;
}
Debug.Fail(string.Format("Unsupported CA named type: {0}", type));
return(ConstantType.Object);
}
CAArgument CreateCAArgument(TypeSig ownerType, object value)
{
if (value == null || value is Null)
{
var t = ownerType.RemovePinnedAndModifiers();
t = t is SZArraySig ? t.Next : t;
if (t.RemovePinnedAndModifiers().GetElementType() == ElementType.Object)
{
return(new CAArgument(module.CorLibTypes.String, null));
}
return(new CAArgument(ownerType, null));
}
switch (ModelUtils.GetElementType(value.GetType()))
{
case ElementType.Boolean: return(new CAArgument(module.CorLibTypes.Boolean, value));
case ElementType.Char: return(new CAArgument(module.CorLibTypes.Char, value));
case ElementType.I1: return(new CAArgument(module.CorLibTypes.SByte, value));
case ElementType.U1: return(new CAArgument(module.CorLibTypes.Byte, value));
case ElementType.I2: return(new CAArgument(module.CorLibTypes.Int16, value));
case ElementType.U2: return(new CAArgument(module.CorLibTypes.UInt16, value));
case ElementType.I4: return(new CAArgument(module.CorLibTypes.Int32, value));
case ElementType.U4: return(new CAArgument(module.CorLibTypes.UInt32, value));
case ElementType.I8: return(new CAArgument(module.CorLibTypes.Int64, value));
case ElementType.U8: return(new CAArgument(module.CorLibTypes.UInt64, value));
case ElementType.R4: return(new CAArgument(module.CorLibTypes.Single, value));
case ElementType.R8: return(new CAArgument(module.CorLibTypes.Double, value));
case ElementType.String: return(new CAArgument(module.CorLibTypes.String, new UTF8String((string)value)));
}
if (value is TypeSig)
{
return(new CAArgument(new ClassSig(module.CorLibTypes.GetTypeRef("System", "Type")), value));
}
if (value is EnumInfo)
{
var enumInfo = (EnumInfo)value;
var enumSig = enumInfo.EnumType.ToTypeSig();
if (!enumInfo.IsArray)
{
return(new CAArgument(enumSig, enumInfo.Value));
}
var res = CreateArray(enumSig, enumInfo.Value);
var list = (IList <CAArgument>)res.Value;
if (list != null)
{
for (int i = 0; i < list.Count; i++)
{
list[i] = new CAArgument(enumSig, list[i].Value);
}
}
return(res);
}
var valueType = value.GetType();
if (value is IList <bool> )
{
return(CreateArray(module.CorLibTypes.Boolean, value));
}
if (value is IList <char> )
{
return(CreateArray(module.CorLibTypes.Char, value));
}
if (value is IList <sbyte> && valueType != typeof(byte[]))
{
return(CreateArray(module.CorLibTypes.SByte, value));
}
if (value is IList <short> && valueType != typeof(ushort[]))
{
return(CreateArray(module.CorLibTypes.Int16, value));
}
if (value is IList <int> && valueType != typeof(uint[]))
{
return(CreateArray(module.CorLibTypes.Int32, value));
}
if (value is IList <long> && valueType != typeof(ulong[]))
{
return(CreateArray(module.CorLibTypes.Int64, value));
}
if (value is IList <byte> && valueType != typeof(sbyte[]))
{
return(CreateArray(module.CorLibTypes.Byte, value));
}
if (value is IList <ushort> && valueType != typeof(short[]))
{
return(CreateArray(module.CorLibTypes.UInt16, value));
}
if (value is IList <uint> && valueType != typeof(int[]))
{
return(CreateArray(module.CorLibTypes.UInt32, value));
}
if (value is IList <ulong> && valueType != typeof(long[]))
{
return(CreateArray(module.CorLibTypes.UInt64, value));
}
if (value is IList <float> )
{
return(CreateArray(module.CorLibTypes.Single, value));
}
if (value is IList <double> )
{
return(CreateArray(module.CorLibTypes.Double, value));
}
if (value is IList <string> )
{
return(CreateArray(module.CorLibTypes.String, value));
}
if (value is IList <TypeSig> )
{
return(CreateArray(new ClassSig(module.CorLibTypes.GetTypeRef("System", "Type")), value));
}
if (value is IList <object> )
{
return(CreateArray(module.CorLibTypes.Object, value));
}
Debug.Fail(string.Format("Unknown CA arg: {0}, ownerType: {1}", value, ownerType));
return(new CAArgument());
}
object ConvertFromModel(TypeSig valueType, object value)
{
var type = valueType.RemovePinnedAndModifiers();
var et = type.GetElementType();
ITypeDefOrRef tdr;
TypeDef td;
switch (et)
{
case ElementType.Boolean:
case ElementType.Char:
case ElementType.I1:
case ElementType.U1:
case ElementType.I2:
case ElementType.U2:
case ElementType.I4:
case ElementType.U4:
case ElementType.I8:
case ElementType.U8:
case ElementType.R4:
case ElementType.R8:
if (ModelUtils.GetElementType(value?.GetType()) == et)
{
return(value);
}
break;
case ElementType.String:
if (value == null)
{
return(Null <string> .Instance);
}
else if (value is string)
{
return(value);
}
else if (value is UTF8String)
{
return(((UTF8String)value).String);
}
break;
case ElementType.ValueType:
case ElementType.Class:
tdr = ((ClassOrValueTypeSig)type).TypeDefOrRef;
if (tdr.IsSystemType())
{
if (value == null)
{
return(Null <TypeSig> .Instance);
}
return(value);
}
td = tdr.ResolveTypeDef();
if (td != null && !td.IsEnum)
{
break;
}
return(new EnumInfo()
{
EnumType = tdr,
Value = value,
IsArray = false,
});
case ElementType.SZArray:
var elemType = type.Next.RemovePinnedAndModifiers();
if (value == null)
{
switch (elemType.GetElementType())
{
case ElementType.Boolean: return(Null <bool[]> .Instance);
case ElementType.Char: return(Null <char[]> .Instance);
case ElementType.I1: return(Null <sbyte[]> .Instance);
case ElementType.U1: return(Null <byte[]> .Instance);
case ElementType.I2: return(Null <short[]> .Instance);
case ElementType.U2: return(Null <ushort[]> .Instance);
case ElementType.I4: return(Null <int[]> .Instance);
case ElementType.U4: return(Null <uint[]> .Instance);
case ElementType.I8: return(Null <long[]> .Instance);
case ElementType.U8: return(Null <ulong[]> .Instance);
case ElementType.R4: return(Null <float[]> .Instance);
case ElementType.R8: return(Null <double[]> .Instance);
case ElementType.String: return(Null <string[]> .Instance);
case ElementType.Object: return(Null <object[]> .Instance);
case ElementType.ValueType:
case ElementType.Class:
tdr = ((ClassOrValueTypeSig)elemType).TypeDefOrRef;
if (tdr.IsSystemType())
{
return(Null <Type[]> .Instance);
}
td = tdr.ResolveTypeDef();
if (td != null && !td.IsEnum)
{
break;
}
return(EnumInfo.CreateNullArray(tdr));
}
break;
}
var oldList = value as IList <CAArgument>;
if (oldList == null)
{
break;
}
switch (elemType.GetElementType())
{
case ElementType.Boolean: return(ConvertArray <bool>(elemType, oldList));
case ElementType.Char: return(ConvertArray <char>(elemType, oldList));
case ElementType.I1: return(ConvertArray <sbyte>(elemType, oldList));
case ElementType.U1: return(ConvertArray <byte>(elemType, oldList));
case ElementType.I2: return(ConvertArray <short>(elemType, oldList));
case ElementType.U2: return(ConvertArray <ushort>(elemType, oldList));
case ElementType.I4: return(ConvertArray <int>(elemType, oldList));
case ElementType.U4: return(ConvertArray <uint>(elemType, oldList));
case ElementType.I8: return(ConvertArray <long>(elemType, oldList));
case ElementType.U8: return(ConvertArray <ulong>(elemType, oldList));
case ElementType.R4: return(ConvertArray <float>(elemType, oldList));
case ElementType.R8: return(ConvertArray <double>(elemType, oldList));
case ElementType.String: return(ConvertArray <string>(elemType, oldList));
case ElementType.Object: return(ConvertArray <object>(elemType, oldList));
case ElementType.ValueType:
case ElementType.Class:
tdr = ((ClassOrValueTypeSig)elemType).TypeDefOrRef;
if (tdr.IsSystemType())
{
return(ConvertArray <TypeSig>(elemType, oldList));
}
td = tdr.ResolveTypeDef();
if (td != null && !td.IsEnum)
{
break;
}
return(ConvertEnum(elemType, oldList));
}
break;
default:
break;
}
return(value);
}
static bool IsSystemVoid(TypeSig type)
{
return(type.RemovePinnedAndModifiers().GetElementType() == ElementType.Void);
}
static bool IsSystemVoid(TypeSig type) {
return type.RemovePinnedAndModifiers().GetElementType() == ElementType.Void;
}
bool IsValidType(TypeSig type)
{
type = type.RemovePinnedAndModifiers();
if (type == null)
{
return(false);
}
if (type.ElementType == ElementType.Void)
{
return(false);
}
while (type != null)
{
switch (type.ElementType)
{
case ElementType.SZArray:
case ElementType.Array:
case ElementType.GenericInst:
case ElementType.Ptr:
case ElementType.Class:
case ElementType.ValueType:
case ElementType.FnPtr:
case ElementType.Void:
case ElementType.Boolean:
case ElementType.Char:
case ElementType.I1:
case ElementType.U1:
case ElementType.I2:
case ElementType.U2:
case ElementType.I4:
case ElementType.U4:
case ElementType.I8:
case ElementType.U8:
case ElementType.R4:
case ElementType.R8:
case ElementType.TypedByRef:
case ElementType.I:
case ElementType.U:
case ElementType.String:
case ElementType.Object:
break;
case ElementType.MVar:
var gmvar = (GenericMVar)type;
if (gmvar.Number >= method.MethodSig.GetGenParamCount())
{
return(false);
}
break;
case ElementType.Var:
var gvar = (GenericVar)type;
var dt = method.DeclaringType;
if (dt == null || gvar.Number >= dt.GenericParameters.Count)
{
return(false);
}
break;
case ElementType.ByRef:
case ElementType.CModOpt:
case ElementType.CModReqd:
case ElementType.Pinned:
case ElementType.Sentinel:
case ElementType.ValueArray:
case ElementType.R:
case ElementType.End:
case ElementType.Internal:
case ElementType.Module:
default:
return(false);
}
if (type.Next == null)
{
break;
}
type = type.Next;
}
return(type != null);
}
public static TypeDesc TryResolveTypeSig(ExecutionEngine executionEngine, MethodDesc method, TypeSig typeSig)
{
return(TryResolveTypeSigImpl(executionEngine, method, typeSig.RemovePinnedAndModifiers()));
}
public static object GetDefaultValue(TypeSig type, bool classValueTypeIsEnum = false)
{
var t = type.RemovePinnedAndModifiers();
switch (t.GetElementType())
{
case ElementType.Boolean: return(false);
case ElementType.Char: return((char)0);
case ElementType.I1: return((sbyte)0);
case ElementType.U1: return((byte)0);
case ElementType.I2: return((short)0);
case ElementType.U2: return((ushort)0);
case ElementType.I4: return((int)0);
case ElementType.U4: return((uint)0);
case ElementType.I8: return((long)0);
case ElementType.U8: return((ulong)0);
case ElementType.R4: return((float)0);
case ElementType.R8: return((double)0);
case ElementType.Class:
case ElementType.ValueType:
var tdr = ((ClassOrValueTypeSig)t).TypeDefOrRef;
if (tdr.IsSystemType())
{
break;
}
var td = tdr.ResolveTypeDef();
if (td == null)
{
if (classValueTypeIsEnum)
{
return((int)0);
}
break;
}
if (!td.IsEnum)
{
break;
}
switch (td.GetEnumUnderlyingType().RemovePinnedAndModifiers().GetElementType())
{
case ElementType.Boolean: return(false);
case ElementType.Char: return((char)0);
case ElementType.I1: return((sbyte)0);
case ElementType.U1: return((byte)0);
case ElementType.I2: return((short)0);
case ElementType.U2: return((ushort)0);
case ElementType.I4: return((int)0);
case ElementType.U4: return((uint)0);
case ElementType.I8: return((long)0);
case ElementType.U8: return((ulong)0);
case ElementType.R4: return((float)0);
case ElementType.R8: return((double)0);
}
break;
}
return(null);
}
private static bool IsSystemVoid(TypeSig type) => type.RemovePinnedAndModifiers().GetElementType() == ElementType.Void;
static void AppendTypeName(StringBuilder b, TypeSig type)
{
type = type.RemovePinnedAndModifiers();
if (type is null)
{
return;
}
if (type is GenericInstSig giType)
{
AppendTypeNameWithArguments(b, giType.GenericType is null ? null : giType.GenericType.TypeDefOrRef, giType.GenericArguments);
return;
}
if (type is ArraySigBase arrayType)
{
AppendTypeName(b, arrayType.Next);
b.Append('[');
var lowerBounds = arrayType.GetLowerBounds();
var sizes = arrayType.GetSizes();
for (int i = 0; i < arrayType.Rank; i++)
{
if (i > 0)
{
b.Append(',');
}
if (i < lowerBounds.Count && i < sizes.Count)
{
b.Append(lowerBounds[i]);
b.Append(':');
b.Append(sizes[i] + lowerBounds[i] - 1);
}
}
b.Append(']');
return;
}
if (type is ByRefSig refType)
{
AppendTypeName(b, refType.Next);
b.Append('@');
return;
}
if (type is PtrSig ptrType)
{
AppendTypeName(b, ptrType.Next);
b.Append('*');
return;
}
if (type is GenericSig gp)
{
b.Append('`');
if (gp.IsMethodVar)
{
b.Append('`');
}
b.Append(gp.Number);
}
else
{
var typeRef = type.ToTypeDefOrRef();
if (typeRef.DeclaringType is not null)
{
AppendTypeName(b, typeRef.DeclaringType.ToTypeSig());
b.Append('.');
b.Append(typeRef.Name);
}
else
{
FullNameFactory.FullNameSB(type, false, null, null, null, b);
}
}
}
byte[] GetData(TypeSig typeSig, int level)
{
if (level >= 10)
{
return(null);
}
var retType = typeSig.RemovePinnedAndModifiers();
if (retType == null)
{
return(null);
}
switch (retType.ElementType)
{
case ElementType.Void:
return(dataVoidReturnType);
case ElementType.Boolean:
case ElementType.Char:
case ElementType.I1:
case ElementType.U1:
case ElementType.I2:
case ElementType.U2:
case ElementType.I4:
case ElementType.U4:
return(dataInt32ReturnType);
case ElementType.I8:
case ElementType.U8:
return(dataInt64ReturnType);
case ElementType.R4:
return(dataSingleReturnType);
case ElementType.R8:
return(dataDoubleReturnType);
case ElementType.I:
return(dataIntPtrReturnType);
case ElementType.U:
case ElementType.Ptr:
case ElementType.FnPtr:
return(dataUIntPtrReturnType);
case ElementType.ValueType:
var td = ((ValueTypeSig)retType).TypeDefOrRef.ResolveTypeDef();
if (td != null && td.IsEnum)
{
var undType = td.GetEnumUnderlyingType().RemovePinnedAndModifiers();
var et = undType.GetElementType();
if ((ElementType.Boolean <= et && et <= ElementType.R8) || et == ElementType.I || et == ElementType.U)
{
return(GetData(undType, level + 1));
}
}
goto case ElementType.TypedByRef;
case ElementType.TypedByRef:
case ElementType.Var:
case ElementType.MVar:
// Need ldloca, initobj, ldloc and a local variable
return(null);
case ElementType.GenericInst:
if (((GenericInstSig)retType).GenericType is ValueTypeSig)
{
goto case ElementType.TypedByRef;
}
goto case ElementType.Class;
case ElementType.End:
case ElementType.String:
case ElementType.ByRef:
case ElementType.Class:
case ElementType.Array:
case ElementType.ValueArray:
case ElementType.R:
case ElementType.Object:
case ElementType.SZArray:
case ElementType.CModReqd:
case ElementType.CModOpt:
case ElementType.Internal:
case ElementType.Module:
case ElementType.Sentinel:
case ElementType.Pinned:
default:
return(dataRefTypeReturnType);
}
}
