public static bool IsValid(CorElementType elementType)
{
return (CorElementType.End <= elementType && elementType <= CorElementType.Max) ||
elementType == CorElementType.Modifier ||
elementType == CorElementType.Sentinel ||
elementType == CorElementType.Pinned;
}
public MiniParameterInfo(CorElementType elementType)
{
System.Diagnostics.Contracts.Contract.Requires(elementType <= CorElementType.String ||
elementType == CorElementType.I || elementType == CorElementType.U ||
elementType == CorElementType.Object);
_elementType = elementType;
}
public MiniParameterInfo(CorElementType elementType, TypeInfo parameterType)
{
System.Diagnostics.Contracts.Contract.Requires(parameterType != null);
System.Diagnostics.Contracts.Contract.Requires(IsValid(elementType));
_elementType = elementType;
_paramType = parameterType;
}
public CorFieldInfo(CorType ownerType, uint token, string name, TypeSig fieldType, FieldAttributes attrs, object constant, CorElementType constantType, DebuggerBrowsableState? debuggerBrowsableState, bool compilerGeneratedAttribute) {
this.OwnerType = ownerType;
this.Token = token;
this.Name = name;
this.FieldType = fieldType;
this.Attributes = attrs;
this.Constant = constant;
this.ConstantType = constantType;
this.DebuggerBrowsableState = debuggerBrowsableState;
this.CompilerGeneratedAttribute = compilerGeneratedAttribute;
}
public DebuggerType(Debugger debugger, CorType type, uint token = 0)
{
debugger.Dispatcher.VerifyAccess();
this.debugger = debugger;
this.type = type;
this.hashCode = type.GetHashCode();
this.elementType = (CorElementType)type.ElementType;
this.attributes = type.GetTypeAttributes();
this.token = token;
this.tokenInitd = token != 0;
}
public CorType GetParameterizedType(CorElementType elementType, CorType[] typeArguments)
{
ICorDebugType[] types = null;
uint length = 0;
if (typeArguments != null)
{
types = new ICorDebugType[typeArguments.Length];
for (int i = 0; i < typeArguments.Length; i++)
types[i] = typeArguments[i].m_type;
length = (uint)typeArguments.Length;
}
ICorDebugType pType;
(m_class as ICorDebugClass2).GetParameterizedType(elementType, length, types, out pType);
return pType==null?null:new CorType (pType);
}
IDebuggerType GetPrimitiveType(CorElementType etype) {
switch (etype) {
case CorElementType.Void: return appDomain.Void;
case CorElementType.Boolean: return appDomain.Boolean;
case CorElementType.Char: return appDomain.Char;
case CorElementType.I1: return appDomain.SByte;
case CorElementType.U1: return appDomain.Byte;
case CorElementType.I2: return appDomain.Int16;
case CorElementType.U2: return appDomain.UInt16;
case CorElementType.I4: return appDomain.Int32;
case CorElementType.U4: return appDomain.UInt32;
case CorElementType.I8: return appDomain.Int64;
case CorElementType.U8: return appDomain.UInt64;
case CorElementType.R4: return appDomain.Single;
case CorElementType.R8: return appDomain.Double;
case CorElementType.String: return appDomain.String;
case CorElementType.TypedByRef: return appDomain.TypedReference;
case CorElementType.I: return appDomain.IntPtr;
case CorElementType.U: return appDomain.UIntPtr;
case CorElementType.Object: return appDomain.Object;
default: return null;
}
}
internal static bool IsSimpleType(CorElementType type)
{
if ((type > CorElementType.String) && (((type != CorElementType.TypedByRef) && (type != CorElementType.I)) && ((type != CorElementType.U) && (type != CorElementType.Object))))
{
return false;
}
return true;
}
private void InternalAddTypeToken(TypeToken clsToken, CorElementType CorType)
{
// Add a type token into signature. CorType will be either CorElementType.Class or CorElementType.ValueType
AddElementType(CorType);
AddToken(clsToken.Token);
}
int ICorDebugType.GetType(out CorElementType ty)
{
// Return CorElementType element type.
ty = m_elemType;
return(Utility.COM_HResults.S_OK);
}
private void AddElementType(CorElementType cvt)
{
if ((this.m_currSig + 1) > this.m_signature.Length)
{
this.m_signature = this.ExpandArray(this.m_signature);
}
this.m_signature[this.m_currSig++] = (byte) cvt;
}
public MiniCustomAttributeNamedArgInfo(CorElementType type, String name, Object value)
{
_argName = name;
_type = type;
_value = value;
}
public unsafe static object GetFieldConstant(IMetaDataImport mdi, uint token, out CorElementType constantType) {
constantType = CorElementType.End;
if (mdi == null)
return null;
uint cchValue;
IntPtr pValue;
CorElementType constantTypeTmp;
int hr = mdi.GetFieldProps(token, IntPtr.Zero, IntPtr.Zero, 0, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, new IntPtr(&constantTypeTmp), new IntPtr(&pValue), new IntPtr(&cchValue));
if (hr < 0 || pValue == IntPtr.Zero)
return null;
constantType = constantTypeTmp;
return ReadConstant(pValue, cchValue, constantType);
}
public Object UnsafeGetValueAsType(CorElementType type)
{
switch (type)
{
case CorElementType.ELEMENT_TYPE_BOOLEAN:
byte bValue = 4; // just initialize to avoid compiler warnings
unsafe
{
Debug.Assert(this.Size == sizeof(byte));
this.GetValueInternal(new IntPtr(&bValue));
}
return((object)(bValue != 0));
case CorElementType.ELEMENT_TYPE_CHAR:
char cValue = 'a'; // initialize to avoid compiler warnings
unsafe
{
Debug.Assert(this.Size == sizeof(char));
this.GetValueInternal(new IntPtr(&cValue));
}
return((object)cValue);
case CorElementType.ELEMENT_TYPE_I1:
SByte i1Value = 4;
unsafe
{
Debug.Assert(this.Size == sizeof(SByte));
this.GetValueInternal(new IntPtr(&i1Value));
}
return((object)i1Value);
case CorElementType.ELEMENT_TYPE_U1:
Byte u1Value = 4;
unsafe
{
Debug.Assert(this.Size == sizeof(Byte));
this.GetValueInternal(new IntPtr(&u1Value));
}
return((object)u1Value);
case CorElementType.ELEMENT_TYPE_I2:
Int16 i2Value = 4;
unsafe
{
Debug.Assert(this.Size == sizeof(Int16));
this.GetValueInternal(new IntPtr(&i2Value));
}
return((object)i2Value);
case CorElementType.ELEMENT_TYPE_U2:
UInt16 u2Value = 4;
unsafe
{
Debug.Assert(this.Size == sizeof(UInt16));
this.GetValueInternal(new IntPtr(&u2Value));
}
return((object)u2Value);
case CorElementType.ELEMENT_TYPE_I:
IntPtr ipValue = IntPtr.Zero;
unsafe
{
Debug.Assert(this.Size == sizeof(IntPtr));
this.GetValueInternal(new IntPtr(&ipValue));
}
return((object)ipValue);
case CorElementType.ELEMENT_TYPE_U:
UIntPtr uipValue = UIntPtr.Zero;
unsafe
{
Debug.Assert(this.Size == sizeof(UIntPtr));
this.GetValueInternal(new IntPtr(&uipValue));
}
return((object)uipValue);
case CorElementType.ELEMENT_TYPE_I4:
Int32 i4Value = 4;
unsafe
{
Debug.Assert(this.Size == sizeof(Int32));
this.GetValueInternal(new IntPtr(&i4Value));
}
return((object)i4Value);
case CorElementType.ELEMENT_TYPE_U4:
UInt32 u4Value = 4;
unsafe
{
Debug.Assert(this.Size == sizeof(UInt32));
this.GetValueInternal(new IntPtr(&u4Value));
}
return((object)u4Value);
case CorElementType.ELEMENT_TYPE_I8:
Int64 i8Value = 4;
unsafe
{
Debug.Assert(this.Size == sizeof(Int64));
this.GetValueInternal(new IntPtr(&i8Value));
}
return((object)i8Value);
case CorElementType.ELEMENT_TYPE_U8:
UInt64 u8Value = 4;
unsafe
{
Debug.Assert(this.Size == sizeof(UInt64));
this.GetValueInternal(new IntPtr(&u8Value));
}
return((object)u8Value);
case CorElementType.ELEMENT_TYPE_R4:
Single r4Value = 4;
unsafe
{
Debug.Assert(this.Size == sizeof(Single));
this.GetValueInternal(new IntPtr(&r4Value));
}
return((object)r4Value);
case CorElementType.ELEMENT_TYPE_R8:
Double r8Value = 4;
unsafe
{
Debug.Assert(this.Size == sizeof(Double));
this.GetValueInternal(new IntPtr(&r8Value));
}
return((object)r8Value);
case CorElementType.ELEMENT_TYPE_VALUETYPE:
byte[] buffer = new byte[this.Size];
unsafe
{
fixed(byte *bufferPtr = &buffer[0])
{
Debug.Assert(this.Size == buffer.Length);
this.GetValueInternal(new IntPtr(bufferPtr));
}
}
return(buffer);
default:
Debug.Assert(false, "Generic value should not be of any other type");
throw new NotSupportedException();
}
}
[System.Security.SecurityCritical] // auto-generated
public String GetDefaultValue(int mdToken, out long value, out int length, out CorElementType corElementType)
{
int _corElementType;
String stringVal;
stringVal = _GetDefaultValue(m_metadataImport2, mdToken, out value, out length, out _corElementType);
corElementType = (CorElementType)_corElementType;
return stringVal;
}
internal static RhCorElementTypeInfo GetRhCorElementTypeInfo(CorElementType elementType)
{
return(RhCorElementTypeInfo.GetRhCorElementTypeInfo(elementType));
}
internal static RhCorElementTypeInfo GetRhCorElementTypeInfo(CorElementType elementType)
{
//TODO Fix crashes from static array fields
RhCorElementTypeInfo[] s_lookupTable = new RhCorElementTypeInfo[]
{
// index = 0x0
new RhCorElementTypeInfo {
_widenMask = 0x0000, _flags = 0
},
// index = 0x1
new RhCorElementTypeInfo {
_widenMask = 0x0000, _flags = 0
},
// index = 0x2 = ELEMENT_TYPE_BOOLEAN (W = BOOL)
new RhCorElementTypeInfo
{
_widenMask = 0x0004,
_flags = RhCorElementTypeInfoFlags.IsValid | RhCorElementTypeInfoFlags.IsPrimitive
},
// index = 0x3 = ELEMENT_TYPE_CHAR (W = U2, CHAR, I4, U4, I8, U8, R4, R8) (U2 == Char)
new RhCorElementTypeInfo
{
_widenMask = 0x3f88,
_flags = RhCorElementTypeInfoFlags.IsValid | RhCorElementTypeInfoFlags.IsPrimitive
},
// index = 0x4 = ELEMENT_TYPE_I1 (W = I1, I2, I4, I8, R4, R8)
new RhCorElementTypeInfo
{
_widenMask = 0x3550,
_flags = RhCorElementTypeInfoFlags.IsValid | RhCorElementTypeInfoFlags.IsPrimitive
},
// index = 0x5 = ELEMENT_TYPE_U1 (W = CHAR, U1, I2, U2, I4, U4, I8, U8, R4, R8)
new RhCorElementTypeInfo
{
_widenMask = 0x3FE8,
_flags = RhCorElementTypeInfoFlags.IsValid | RhCorElementTypeInfoFlags.IsPrimitive
},
// index = 0x6 = ELEMENT_TYPE_I2 (W = I2, I4, I8, R4, R8)
new RhCorElementTypeInfo
{
_widenMask = 0x3540,
_flags = RhCorElementTypeInfoFlags.IsValid | RhCorElementTypeInfoFlags.IsPrimitive
},
// index = 0x7 = ELEMENT_TYPE_U2 (W = U2, CHAR, I4, U4, I8, U8, R4, R8)
new RhCorElementTypeInfo
{
_widenMask = 0x3F88,
_flags = RhCorElementTypeInfoFlags.IsValid | RhCorElementTypeInfoFlags.IsPrimitive
},
// index = 0x8 = ELEMENT_TYPE_I4 (W = I4, I8, R4, R8)
new RhCorElementTypeInfo
{
_widenMask = 0x3500,
_flags = RhCorElementTypeInfoFlags.IsValid | RhCorElementTypeInfoFlags.IsPrimitive
},
// index = 0x9 = ELEMENT_TYPE_U4 (W = U4, I8, R4, R8)
new RhCorElementTypeInfo
{
_widenMask = 0x3E00,
_flags = RhCorElementTypeInfoFlags.IsValid | RhCorElementTypeInfoFlags.IsPrimitive
},
// index = 0xa = ELEMENT_TYPE_I8 (W = I8, R4, R8)
new RhCorElementTypeInfo
{
_widenMask = 0x3400,
_flags = RhCorElementTypeInfoFlags.IsValid | RhCorElementTypeInfoFlags.IsPrimitive
},
// index = 0xb = ELEMENT_TYPE_U8 (W = U8, R4, R8)
new RhCorElementTypeInfo
{
_widenMask = 0x3800,
_flags = RhCorElementTypeInfoFlags.IsValid | RhCorElementTypeInfoFlags.IsPrimitive
},
// index = 0xc = ELEMENT_TYPE_R4 (W = R4, R8)
new RhCorElementTypeInfo
{
_widenMask = 0x3000,
_flags = RhCorElementTypeInfoFlags.IsValid | RhCorElementTypeInfoFlags.IsPrimitive |
RhCorElementTypeInfoFlags.IsFloat
},
// index = 0xd = ELEMENT_TYPE_R8 (W = R8)
new RhCorElementTypeInfo
{
_widenMask = 0x2000,
_flags = RhCorElementTypeInfoFlags.IsValid | RhCorElementTypeInfoFlags.IsPrimitive |
RhCorElementTypeInfoFlags.IsFloat
},
// index = 0xe
new RhCorElementTypeInfo {
_widenMask = 0x0000, _flags = 0
},
// index = 0xf
new RhCorElementTypeInfo {
_widenMask = 0x0000, _flags = 0
},
// index = 0x10
new RhCorElementTypeInfo {
_widenMask = 0x0000, _flags = 0
},
// index = 0x11
new RhCorElementTypeInfo {
_widenMask = 0x0000, _flags = 0
},
// index = 0x12
new RhCorElementTypeInfo {
_widenMask = 0x0000, _flags = 0
},
// index = 0x13
new RhCorElementTypeInfo {
_widenMask = 0x0000, _flags = 0
},
// index = 0x14
new RhCorElementTypeInfo {
_widenMask = 0x0000, _flags = 0
},
// index = 0x15
new RhCorElementTypeInfo {
_widenMask = 0x0000, _flags = 0
},
// index = 0x16
new RhCorElementTypeInfo {
_widenMask = 0x0000, _flags = 0
},
// index = 0x17
new RhCorElementTypeInfo {
_widenMask = 0x0000, _flags = 0
},
// index = 0x18 = ELEMENT_TYPE_I
new RhCorElementTypeInfo
{
_widenMask = 0x0000,
_flags = RhCorElementTypeInfoFlags.IsValid | RhCorElementTypeInfoFlags.IsPrimitive
},
// index = 0x19 = ELEMENT_TYPE_U
new RhCorElementTypeInfo
{
_widenMask = 0x0000,
_flags = RhCorElementTypeInfoFlags.IsValid | RhCorElementTypeInfoFlags.IsPrimitive
},
};
// The _lookupTable array only covers a subset of RhCorElementTypes, so we return a default
// info when someone asks for an elementType which does not have an entry in the table.
if ((int)elementType > s_lookupTable.Length)
{
return(default(RhCorElementTypeInfo));
}
RhCorElementTypeInfo result = s_lookupTable[(int)elementType];
s_lookupTable.Free();
return(result);
}
private void InternalAddTypeToken(TypeToken clsToken, CorElementType CorType)
{
// Add a type token into signature. CorType will be either CorElementType.ELEMENT_TYPE_CLASS or CorElementType.ELEMENT_TYPE_VALUETYPE
AddElementType(CorType);
AddToken(clsToken.Token);
}
private void AddOneArgTypeHelperWorker(Type clsArgument, bool lastWasGenericInst)
{
if (clsArgument.IsGenericParameter)
{
if (clsArgument.DeclaringMethod != null)
{
AddElementType(CorElementType.ELEMENT_TYPE_MVAR);
}
else
{
AddElementType(CorElementType.ELEMENT_TYPE_VAR);
}
AddData(clsArgument.GenericParameterPosition);
}
else if (clsArgument.IsGenericType && (!clsArgument.IsGenericTypeDefinition || !lastWasGenericInst))
{
AddElementType(CorElementType.ELEMENT_TYPE_GENERICINST);
AddOneArgTypeHelperWorker(clsArgument.GetGenericTypeDefinition(), true);
Type[] args = clsArgument.GetGenericArguments();
AddData(args.Length);
foreach (Type t in args)
{
AddOneArgTypeHelper(t);
}
}
else if (clsArgument is TypeBuilder)
{
TypeBuilder clsBuilder = (TypeBuilder)clsArgument;
TypeToken tkType;
if (clsBuilder.Module.Equals(m_module))
{
tkType = clsBuilder.TypeToken;
}
else
{
tkType = m_module !.GetTypeToken(clsArgument);
}
if (clsArgument.IsValueType)
{
InternalAddTypeToken(tkType, CorElementType.ELEMENT_TYPE_VALUETYPE);
}
else
{
InternalAddTypeToken(tkType, CorElementType.ELEMENT_TYPE_CLASS);
}
}
else if (clsArgument is EnumBuilder)
{
TypeBuilder clsBuilder = ((EnumBuilder)clsArgument).m_typeBuilder;
TypeToken tkType;
if (clsBuilder.Module.Equals(m_module))
{
tkType = clsBuilder.TypeToken;
}
else
{
tkType = m_module !.GetTypeToken(clsArgument);
}
if (clsArgument.IsValueType)
{
InternalAddTypeToken(tkType, CorElementType.ELEMENT_TYPE_VALUETYPE);
}
else
{
InternalAddTypeToken(tkType, CorElementType.ELEMENT_TYPE_CLASS);
}
}
else if (clsArgument.IsByRef)
{
AddElementType(CorElementType.ELEMENT_TYPE_BYREF);
clsArgument = clsArgument.GetElementType() !;
AddOneArgTypeHelper(clsArgument);
}
else if (clsArgument.IsPointer)
{
AddElementType(CorElementType.ELEMENT_TYPE_PTR);
AddOneArgTypeHelper(clsArgument.GetElementType() !);
}
else if (clsArgument.IsArray)
{
if (clsArgument.IsSZArray)
{
AddElementType(CorElementType.ELEMENT_TYPE_SZARRAY);
AddOneArgTypeHelper(clsArgument.GetElementType() !);
}
else
{
AddElementType(CorElementType.ELEMENT_TYPE_ARRAY);
AddOneArgTypeHelper(clsArgument.GetElementType() !);
// put the rank information
int rank = clsArgument.GetArrayRank();
AddData(rank); // rank
AddData(0); // upper bounds
AddData(rank); // lower bound
for (int i = 0; i < rank; i++)
{
AddData(0);
}
}
}
else
{
CorElementType type = CorElementType.ELEMENT_TYPE_MAX;
if (clsArgument is RuntimeType)
{
type = RuntimeTypeHandle.GetCorElementType((RuntimeType)clsArgument);
// GetCorElementType returns CorElementType.ELEMENT_TYPE_CLASS for both object and string
if (type == CorElementType.ELEMENT_TYPE_CLASS)
{
if (clsArgument == typeof(object))
{
type = CorElementType.ELEMENT_TYPE_OBJECT;
}
else if (clsArgument == typeof(string))
{
type = CorElementType.ELEMENT_TYPE_STRING;
}
}
}
if (IsSimpleType(type))
{
AddElementType(type);
}
else if (m_module == null)
{
InternalAddRuntimeType(clsArgument);
}
else if (clsArgument.IsValueType)
{
InternalAddTypeToken(m_module.GetTypeToken(clsArgument), CorElementType.ELEMENT_TYPE_VALUETYPE);
}
else
{
InternalAddTypeToken(m_module.GetTypeToken(clsArgument), CorElementType.ELEMENT_TYPE_CLASS);
}
}
}
private void GetElementTypeInfo(
EcmaModule module,
FieldDesc fieldDesc,
EntityHandle valueTypeHandle,
CorElementType elementType,
int pointerSize,
bool moduleLayout,
out int alignment,
out int size,
out bool isGcPointerField,
out bool isGcBoxedField)
{
alignment = 1;
size = 0;
isGcPointerField = false;
isGcBoxedField = false;
switch (elementType)
{
case CorElementType.ELEMENT_TYPE_I1:
case CorElementType.ELEMENT_TYPE_U1:
case CorElementType.ELEMENT_TYPE_BOOLEAN:
size = 1;
break;
case CorElementType.ELEMENT_TYPE_I2:
case CorElementType.ELEMENT_TYPE_U2:
case CorElementType.ELEMENT_TYPE_CHAR:
alignment = 2;
size = 2;
break;
case CorElementType.ELEMENT_TYPE_I4:
case CorElementType.ELEMENT_TYPE_U4:
case CorElementType.ELEMENT_TYPE_R4:
alignment = 4;
size = 4;
break;
case CorElementType.ELEMENT_TYPE_FNPTR:
case CorElementType.ELEMENT_TYPE_PTR:
case CorElementType.ELEMENT_TYPE_I:
case CorElementType.ELEMENT_TYPE_U:
alignment = pointerSize;
size = pointerSize;
break;
case CorElementType.ELEMENT_TYPE_I8:
case CorElementType.ELEMENT_TYPE_U8:
case CorElementType.ELEMENT_TYPE_R8:
alignment = 8;
size = 8;
break;
case CorElementType.ELEMENT_TYPE_VAR:
case CorElementType.ELEMENT_TYPE_MVAR:
case CorElementType.ELEMENT_TYPE_STRING:
case CorElementType.ELEMENT_TYPE_SZARRAY:
case CorElementType.ELEMENT_TYPE_ARRAY:
case CorElementType.ELEMENT_TYPE_CLASS:
case CorElementType.ELEMENT_TYPE_OBJECT:
isGcPointerField = true;
break;
case CorElementType.ELEMENT_TYPE_BYREF:
ThrowHelper.ThrowTypeLoadException(ExceptionStringID.ClassLoadGeneral, fieldDesc.OwningType);
break;
// Statics for valuetypes where the valuetype is defined in this module are handled here.
// Other valuetype statics utilize the pessimistic model below.
case CorElementType.ELEMENT_TYPE_VALUETYPE:
if (IsTypeByRefLike(valueTypeHandle, module.MetadataReader))
{
ThrowHelper.ThrowTypeLoadException(ExceptionStringID.ClassLoadGeneral, fieldDesc.OwningType);
}
if (moduleLayout && fieldDesc.FieldType.GetTypeDefinition() is EcmaType ecmaType && ecmaType.EcmaModule != module)
{
// Allocate pessimistic non-GC area for cross-module fields as that's what CoreCLR does
// <a href="https://github.com/dotnet/coreclr/blob/659af58047a949ed50d11101708538d2e87f2568/src/vm/ceeload.cpp#L2124">here</a>
alignment = TargetDetails.MaximumPrimitiveSize;
size = TargetDetails.MaximumPrimitiveSize;
isGcBoxedField = true;
}
else if (fieldDesc.FieldType.IsEnum)
{
size = fieldDesc.FieldType.UnderlyingType.GetElementSize().AsInt;
alignment = size;
isGcBoxedField = false;
}
else
{
// All struct statics are boxed in CoreCLR
isGcBoxedField = true;
}
break;
public void GetDefaultValue(int mdToken, out long value, out int length, out CorElementType corElementType)
{
int num;
_GetDefaultValue(this.m_metadataImport2, out MetadataArgs.Skip, mdToken, out value, out length, out num);
corElementType = (CorElementType) ((byte) num);
}
public unsafe static object GetValue(MetadataImport scope, int token, RuntimeTypeHandle fieldTypeHandle, bool raw)
{
CorElementType corElementType = CorElementType.End;
long num = 0L;
int num2;
string defaultValue = scope.GetDefaultValue(token, out num, out num2, out corElementType);
RuntimeType runtimeType = fieldTypeHandle.GetRuntimeType();
if (runtimeType.IsEnum && !raw)
{
long value;
switch (corElementType)
{
case CorElementType.Void:
return(DBNull.Value);
case CorElementType.Char:
value = (long)((ulong)(*(ushort *)(&num)));
goto IL_C8;
case CorElementType.I1:
value = (long)(*(sbyte *)(&num));
goto IL_C8;
case CorElementType.U1:
value = (long)((ulong)(*(byte *)(&num)));
goto IL_C8;
case CorElementType.I2:
value = (long)(*(short *)(&num));
goto IL_C8;
case CorElementType.U2:
value = (long)((ulong)(*(ushort *)(&num)));
goto IL_C8;
case CorElementType.I4:
value = (long)(*(int *)(&num));
goto IL_C8;
case CorElementType.U4:
value = (long)((ulong)(*(uint *)(&num)));
goto IL_C8;
case CorElementType.I8:
value = num;
goto IL_C8;
case CorElementType.U8:
value = num;
goto IL_C8;
}
throw new FormatException(Environment.GetResourceString("Arg_BadLiteralFormat"));
IL_C8:
return(RuntimeType.CreateEnum(runtimeType, value));
}
if (!(runtimeType == typeof(DateTime)))
{
switch (corElementType)
{
case CorElementType.Void:
return(DBNull.Value);
case CorElementType.Boolean:
return(*(int *)(&num) != 0);
case CorElementType.Char:
return((char)(*(ushort *)(&num)));
case CorElementType.I1:
return(*(sbyte *)(&num));
case CorElementType.U1:
return(*(byte *)(&num));
case CorElementType.I2:
return(*(short *)(&num));
case CorElementType.U2:
return(*(ushort *)(&num));
case CorElementType.I4:
return(*(int *)(&num));
case CorElementType.U4:
return(*(uint *)(&num));
case CorElementType.I8:
return(num);
case CorElementType.U8:
return((ulong)num);
case CorElementType.R4:
return(*(float *)(&num));
case CorElementType.R8:
return(*(double *)(&num));
case CorElementType.String:
if (defaultValue != null)
{
return(defaultValue);
}
return(string.Empty);
case CorElementType.Class:
return(null);
}
throw new FormatException(Environment.GetResourceString("Arg_BadLiteralFormat"));
}
if (corElementType != CorElementType.Void)
{
long ticks;
if (corElementType != CorElementType.I8)
{
if (corElementType != CorElementType.U8)
{
throw new FormatException(Environment.GetResourceString("Arg_BadLiteralFormat"));
}
ticks = num;
}
else
{
ticks = num;
}
return(new DateTime(ticks));
}
return(DBNull.Value);
}
DebugType(Process process, ICorDebugType corType)
{
if (corType == null) throw new ArgumentNullException("corType");
this.process = process;
this.corType = corType;
this.corElementType = (CorElementType)corType.Type;
if (this.IsClass || this.IsValueType) {
this.corClass = corType.Class;
this.module = process.GetModule(corClass.Module);
this.classProps = module.MetaData.GetTypeDefProps(corClass.Token);
}
if (this.IsClass || this.IsValueType || this.IsArray || this.IsPointer) {
foreach(ICorDebugType t in corType.EnumerateTypeParameters().Enumerator) {
typeArguments.Add(DebugType.Create(process, t));
}
}
this.fullName = GetFullName();
}
// Special coersion rules for primitives, enums and pointer.
private static Exception ConvertOrWidenPrimitivesEnumsAndPointersIfPossible(object srcObject, EETypePtr srcEEType, EETypePtr dstEEType, CheckArgumentSemantics semantics, out object dstObject)
{
if (semantics == CheckArgumentSemantics.SetFieldDirect && (srcEEType.IsEnum || dstEEType.IsEnum))
{
dstObject = null;
return(CreateChangeTypeException(srcEEType, dstEEType, semantics));
}
if (dstEEType.IsPointer)
{
Exception exception = ConvertPointerIfPossible(srcObject, srcEEType, dstEEType, semantics, out IntPtr dstIntPtr);
if (exception != null)
{
dstObject = null;
return(exception);
}
dstObject = dstIntPtr;
return(null);
}
if (!(srcEEType.IsPrimitive && dstEEType.IsPrimitive))
{
dstObject = null;
return(CreateChangeTypeException(srcEEType, dstEEType, semantics));
}
CorElementType dstCorElementType = dstEEType.CorElementType;
if (!srcEEType.CorElementTypeInfo.CanWidenTo(dstCorElementType))
{
dstObject = null;
return(CreateChangeTypeArgumentException(srcEEType, dstEEType));
}
switch (dstCorElementType)
{
case CorElementType.ELEMENT_TYPE_BOOLEAN:
bool boolValue = Convert.ToBoolean(srcObject);
dstObject = dstEEType.IsEnum ? Enum.ToObject(dstEEType, boolValue ? 1 : 0) : boolValue;
break;
case CorElementType.ELEMENT_TYPE_CHAR:
char charValue = Convert.ToChar(srcObject);
dstObject = dstEEType.IsEnum ? Enum.ToObject(dstEEType, charValue) : charValue;
break;
case CorElementType.ELEMENT_TYPE_I1:
sbyte sbyteValue = Convert.ToSByte(srcObject);
dstObject = dstEEType.IsEnum ? Enum.ToObject(dstEEType, sbyteValue) : sbyteValue;
break;
case CorElementType.ELEMENT_TYPE_I2:
short shortValue = Convert.ToInt16(srcObject);
dstObject = dstEEType.IsEnum ? Enum.ToObject(dstEEType, shortValue) : shortValue;
break;
case CorElementType.ELEMENT_TYPE_I4:
int intValue = Convert.ToInt32(srcObject);
dstObject = dstEEType.IsEnum ? Enum.ToObject(dstEEType, intValue) : intValue;
break;
case CorElementType.ELEMENT_TYPE_I8:
long longValue = Convert.ToInt64(srcObject);
dstObject = dstEEType.IsEnum ? Enum.ToObject(dstEEType, longValue) : longValue;
break;
case CorElementType.ELEMENT_TYPE_U1:
byte byteValue = Convert.ToByte(srcObject);
dstObject = dstEEType.IsEnum ? Enum.ToObject(dstEEType, byteValue) : byteValue;
break;
case CorElementType.ELEMENT_TYPE_U2:
ushort ushortValue = Convert.ToUInt16(srcObject);
dstObject = dstEEType.IsEnum ? Enum.ToObject(dstEEType, ushortValue) : ushortValue;
break;
case CorElementType.ELEMENT_TYPE_U4:
uint uintValue = Convert.ToUInt32(srcObject);
dstObject = dstEEType.IsEnum ? Enum.ToObject(dstEEType, uintValue) : uintValue;
break;
case CorElementType.ELEMENT_TYPE_U8:
ulong ulongValue = Convert.ToUInt64(srcObject);
dstObject = dstEEType.IsEnum ? Enum.ToObject(dstEEType, (long)ulongValue) : ulongValue;
break;
case CorElementType.ELEMENT_TYPE_R4:
if (srcEEType.CorElementType == CorElementType.ELEMENT_TYPE_CHAR)
{
dstObject = (float)(char)srcObject;
}
else
{
dstObject = Convert.ToSingle(srcObject);
}
break;
case CorElementType.ELEMENT_TYPE_R8:
if (srcEEType.CorElementType == CorElementType.ELEMENT_TYPE_CHAR)
{
dstObject = (double)(char)srcObject;
}
else
{
dstObject = Convert.ToDouble(srcObject);
}
break;
default:
Debug.Fail("Unexpected CorElementType: " + dstCorElementType + ": Not a valid widening target.");
dstObject = null;
return(CreateChangeTypeException(srcEEType, dstEEType, semantics));
}
Debug.Assert(dstObject.EETypePtr == dstEEType);
return(null);
}
static ulong?ParseIntegerConstant(CorElementType etype, string c, out string error)
{
error = null;
long smin, smax;
ulong max;
switch (etype)
{
case CorElementType.Boolean:
smin = 0;
smax = 1;
max = 1;
break;
case CorElementType.I:
if (IntPtr.Size == 4)
{
goto case CorElementType.I4;
}
goto case CorElementType.I8;
case CorElementType.U:
case CorElementType.Ptr:
case CorElementType.FnPtr:
if (UIntPtr.Size == 4)
{
goto case CorElementType.U4;
}
goto case CorElementType.U8;
case CorElementType.I1:
case CorElementType.U1:
smin = sbyte.MinValue;
smax = sbyte.MaxValue;
max = byte.MaxValue;
break;
case CorElementType.I2:
case CorElementType.U2:
smin = short.MinValue;
smax = short.MaxValue;
max = ushort.MaxValue;
break;
case CorElementType.I4:
case CorElementType.U4:
smin = int.MinValue;
smax = int.MaxValue;
max = uint.MaxValue;
break;
case CorElementType.I8:
case CorElementType.U8:
smin = long.MinValue;
smax = long.MaxValue;
max = ulong.MaxValue;
break;
default:
return(null);
}
ulong v = NumberVMUtils.ParseUInt64(c, 0, max, out error);
if (string.IsNullOrEmpty(error))
{
return(v);
}
v = (ulong)NumberVMUtils.ParseInt64(c, smin, smax, out error);
if (string.IsNullOrEmpty(error))
{
return(v);
}
return(null);
}
internal static bool IsByRef(RuntimeType type)
{
CorElementType corElemType = GetCorElementType(type);
return(corElemType == CorElementType.ELEMENT_TYPE_BYREF);
}
/// <summary>
/// Boxes a CorElementType to its internal representation.
/// </summary>
/// <param name="elemType"></param>
/// <returns></returns>
public static object ToInternal(this CorElementType elemType)
{
return(Enum.ToObject(type, (byte)elemType));
}
internal static bool IsPointer(RuntimeType type)
{
CorElementType corElemType = GetCorElementType(type);
return(corElemType == CorElementType.ELEMENT_TYPE_PTR);
}
/// <summary>
/// Decode a type from the signature stream.
/// </summary>
/// <param name="builder"></param>
private void ParseType(StringBuilder builder)
{
CorElementType corElemType = ReadElementType();
switch (corElemType)
{
case CorElementType.ELEMENT_TYPE_VOID:
builder.Append("void");
break;
case CorElementType.ELEMENT_TYPE_BOOLEAN:
builder.Append("bool");
break;
case CorElementType.ELEMENT_TYPE_CHAR:
builder.Append("char");
break;
case CorElementType.ELEMENT_TYPE_I1:
builder.Append("sbyte");
break;
case CorElementType.ELEMENT_TYPE_U1:
builder.Append("byte");
break;
case CorElementType.ELEMENT_TYPE_I2:
builder.Append("short");
break;
case CorElementType.ELEMENT_TYPE_U2:
builder.Append("ushort");
break;
case CorElementType.ELEMENT_TYPE_I4:
builder.Append("int");
break;
case CorElementType.ELEMENT_TYPE_U4:
builder.Append("uint");
break;
case CorElementType.ELEMENT_TYPE_I8:
builder.Append("long");
break;
case CorElementType.ELEMENT_TYPE_U8:
builder.Append("ulong");
break;
case CorElementType.ELEMENT_TYPE_R4:
builder.Append("float");
break;
case CorElementType.ELEMENT_TYPE_R8:
builder.Append("double");
break;
case CorElementType.ELEMENT_TYPE_STRING:
builder.Append("string");
break;
case CorElementType.ELEMENT_TYPE_PTR:
builder.Append("ptr");
break;
case CorElementType.ELEMENT_TYPE_BYREF:
builder.Append("byref");
break;
case CorElementType.ELEMENT_TYPE_VALUETYPE:
case CorElementType.ELEMENT_TYPE_CLASS:
ParseTypeToken(builder);
break;
case CorElementType.ELEMENT_TYPE_VAR:
builder.Append("var");
break;
case CorElementType.ELEMENT_TYPE_ARRAY:
builder.Append("array");
break;
case CorElementType.ELEMENT_TYPE_GENERICINST:
ParseGenericTypeInstance(builder);
break;
case CorElementType.ELEMENT_TYPE_TYPEDBYREF:
builder.Append("typedbyref");
break;
case CorElementType.ELEMENT_TYPE_I:
builder.Append("IntPtr");
break;
case CorElementType.ELEMENT_TYPE_U:
builder.Append("UIntPtr");
break;
case CorElementType.ELEMENT_TYPE_FNPTR:
builder.Append("fnptr");
break;
case CorElementType.ELEMENT_TYPE_OBJECT:
builder.Append("object");
break;
case CorElementType.ELEMENT_TYPE_SZARRAY:
builder.Append("szarray");
break;
case CorElementType.ELEMENT_TYPE_MVAR:
builder.Append("mvar");
break;
case CorElementType.ELEMENT_TYPE_CMOD_REQD:
builder.Append("cmod_reqd");
break;
case CorElementType.ELEMENT_TYPE_CMOD_OPT:
builder.Append("cmod_opt");
break;
case CorElementType.ELEMENT_TYPE_HANDLE:
builder.Append("handle");
break;
case CorElementType.ELEMENT_TYPE_SENTINEL:
builder.Append("sentinel");
break;
case CorElementType.ELEMENT_TYPE_PINNED:
builder.Append("pinned");
break;
case CorElementType.ELEMENT_TYPE_VAR_ZAPSIG:
builder.Append("var_zapsig");
break;
case CorElementType.ELEMENT_TYPE_NATIVE_ARRAY_TEMPLATE_ZAPSIG:
builder.Append("native_array_template_zapsig");
break;
case CorElementType.ELEMENT_TYPE_NATIVE_VALUETYPE_ZAPSIG:
builder.Append("native_valuetype_zapsig");
break;
case CorElementType.ELEMENT_TYPE_CANON_ZAPSIG:
builder.Append("__Canon");
break;
case CorElementType.ELEMENT_TYPE_MODULE_ZAPSIG:
builder.Append("module_zapsig");
break;
default:
throw new NotImplementedException();
}
}
internal static bool IsSzArray(RuntimeType type)
{
CorElementType corElemType = GetCorElementType(type);
return(corElemType == CorElementType.ELEMENT_TYPE_SZARRAY);
}
public CorValue CreateValue(CorElementType et, CorClass cls = null) => eval.CreateValue(et, cls);
protected override TypeCode GetTypeCodeImpl()
{
TypeCode typeCode = Cache.TypeCode;
if (typeCode != TypeCode.Empty)
{
return(typeCode);
}
CorElementType corElementType = RuntimeTypeHandle.GetCorElementType(this);
switch (corElementType)
{
case CorElementType.ELEMENT_TYPE_BOOLEAN:
typeCode = TypeCode.Boolean; break;
case CorElementType.ELEMENT_TYPE_CHAR:
typeCode = TypeCode.Char; break;
case CorElementType.ELEMENT_TYPE_I1:
typeCode = TypeCode.SByte; break;
case CorElementType.ELEMENT_TYPE_U1:
typeCode = TypeCode.Byte; break;
case CorElementType.ELEMENT_TYPE_I2:
typeCode = TypeCode.Int16; break;
case CorElementType.ELEMENT_TYPE_U2:
typeCode = TypeCode.UInt16; break;
case CorElementType.ELEMENT_TYPE_I4:
typeCode = TypeCode.Int32; break;
case CorElementType.ELEMENT_TYPE_U4:
typeCode = TypeCode.UInt32; break;
case CorElementType.ELEMENT_TYPE_I8:
typeCode = TypeCode.Int64; break;
case CorElementType.ELEMENT_TYPE_U8:
typeCode = TypeCode.UInt64; break;
case CorElementType.ELEMENT_TYPE_R4:
typeCode = TypeCode.Single; break;
case CorElementType.ELEMENT_TYPE_R8:
typeCode = TypeCode.Double; break;
case CorElementType.ELEMENT_TYPE_VALUETYPE:
if (this == Convert.ConvertTypes[(int)TypeCode.Decimal])
{
typeCode = TypeCode.Decimal;
}
else if (this == Convert.ConvertTypes[(int)TypeCode.DateTime])
{
typeCode = TypeCode.DateTime;
}
else if (IsEnum)
{
typeCode = GetTypeCode(Enum.GetUnderlyingType(this));
}
else
{
typeCode = TypeCode.Object;
}
break;
default:
if (this == Convert.ConvertTypes[(int)TypeCode.DBNull])
{
typeCode = TypeCode.DBNull;
}
else if (this == Convert.ConvertTypes[(int)TypeCode.String])
{
typeCode = TypeCode.String;
}
else
{
typeCode = TypeCode.Object;
}
break;
}
Cache.TypeCode = typeCode;
return(typeCode);
}
private void InternalAddTypeToken(TypeToken clsToken, CorElementType CorType)
{
this.AddElementType(CorType);
this.AddToken(clsToken.Token);
}
private void SetNameModuleAndFields(CorElementType typeKind, COR_TYPEID typeID, int numFields)
{
// THere is recursion in the definition of primitive types (they have a value field of the primtitive type.
// Cut this off here.
if (GCRootNames.IsPrimitiveType(typeKind))
{
numFields = 0;
}
var buffer = new StringBuilder(1024);
IMetadataImport metaData = null;
int bufferSizeRet;
// This is getting names. If we fail, we can still plow on ....
try
{
ICorDebugType corType = null;
// Console.WriteLine("Calling GetTypeForTypeID {0:x} {1:x}", typeID.token1, typeID.token2);
m_heap.m_process5.GetTypeForTypeID(typeID, out corType);
string moduleFilePath;
m_name = GCRootNames.GetTypeName(corType, out moduleFilePath, out metaData, buffer);
m_moduleFilePath = moduleFilePath;
}
catch (Exception e)
{
Console.WriteLine("Error: Caught exception for type ID {0:x} {1:x}: {2}", typeID.token1, typeID.token2, e.Message);
m_name = string.Format("!ERROR TYPE ID {0:x} {1:x}", typeID.token1, typeID.token2);
m_moduleFilePath = Name;
}
if (numFields > 0)
{
m_fields = new ICorDebugGCHeapField[numFields];
var corFields = new COR_FIELD[numFields];
int fieldsFetched;
m_heap.m_process5.GetTypeFields(typeID, corFields.Length, corFields, out fieldsFetched);
Debug.Assert(fieldsFetched == m_fields.Length);
for (int i = 0; i < corFields.Length; i++)
{
int fieldTypeToken, fieldAttr, sigBlobSize, cplusTypeFlab, fieldValSize;
IntPtr sigBlob, fieldVal;
buffer.Length = 0;
if (metaData != null)
{
metaData.GetFieldProps(corFields[i].token, out fieldTypeToken, buffer, buffer.Capacity, out bufferSizeRet,
out fieldAttr, out sigBlob, out sigBlobSize, out cplusTypeFlab, out fieldVal, out fieldValSize);
}
var fieldName = buffer.ToString();
ICorDebugGCHeapType fieldType = null;
// If the type has never been loaded, then you can get a null field type.
// TODO FIX NOW, think about this.
if (corFields[i].id.token1 != 0 || corFields[i].id.token2 != 0)
{
// Console.WriteLine("Looking up field {0}.{1} typeId {2:x} {3:x}", Name, fieldName, corFields[i].id.token1, corFields[i].id.token2);
Debug.Assert(corFields[i].fieldType != CorElementType.ELEMENT_TYPE_END);
// TODO FIX NOW remove the condition
if (!GCRootNames.IsReferenceType(corFields[i].fieldType))
{
fieldType = m_heap.GetObjectTypeFromID(corFields[i].id);
}
}
else
{
// Console.WriteLine("Warning, NULL type token for {0}.{1} assuming it is an objectRef", Name, fieldName);
// Zero means the type is not loaded. This can only happen if it is a reference type
corFields[i].fieldType = CorElementType.ELEMENT_TYPE_CLASS;
}
// The element types match. (string matches class)
#if DEBUG
if (fieldType != null)
{
var fieldTypeKind = fieldType.TypeKind;
if (fieldTypeKind == CorElementType.ELEMENT_TYPE_STRING)
{
fieldTypeKind = CorElementType.ELEMENT_TYPE_CLASS;
}
if (fieldTypeKind == CorElementType.ELEMENT_TYPE_OBJECT)
{
fieldTypeKind = CorElementType.ELEMENT_TYPE_CLASS;
}
Debug.Assert(fieldTypeKind == corFields[i].fieldType);
}
#endif
m_fields[i] = new ICorDebugGCHeapField(fieldName, corFields[i].offset, fieldType, corFields[i].fieldType);
}
}
}
private void AddElementType(CorElementType cvt)
{
// Adds an element to the signature. A managed represenation of CorSigCompressElement
if (m_currSig + 1 > m_signature.Length)
m_signature = ExpandArray(m_signature);
m_signature[m_currSig++] = (byte)cvt;
}
internal ICorDebugGCHeapField(string name, int offset, ICorDebugGCHeapType fieldType, CorElementType componentType)
{
m_offset = offset;
m_name = name;
m_type = fieldType;
m_ComponentType = componentType;
}
internal static bool IsSimpleType(CorElementType type)
{
if (type <= CorElementType.String)
return true;
if (type == CorElementType.TypedByRef || type == CorElementType.I || type == CorElementType.U || type == CorElementType.Object)
return true;
return false;
}
private static Dictionary <IBCBlobKey, BlobEntry> GetIBCBlobs(List <BlobEntry> inputBlobs, out HashSet <uint> ignoredIbcMethodSpecTokens)
{
Dictionary <IBCBlobKey, BlobEntry> blobs = new Dictionary <IBCBlobKey, BlobEntry>();
ignoredIbcMethodSpecTokens = new HashSet <uint>();
if (inputBlobs != null)
{
foreach (BlobEntry blob in inputBlobs)
{
bool ignore = false;
// Some blob types require special processing
switch (blob.Type)
{
case BlobType.ParamTypeSpec:
case BlobType.ParamMethodSpec:
if ((Cor.Macros.TypeFromToken(blob.Token) == CorTokenType.ibcTypeSpec) ||
(Cor.Macros.TypeFromToken(blob.Token) == CorTokenType.ibcMethodSpec))
{
if (blob.Type == BlobType.ParamMethodSpec)
{
//
// In the ParamMethodSpec case, the full signature was always originally encoded by
// ZapSig::EncodeMethod and therefore always starts with an owning type signature
// originally encoded by ZapSig::GetSignatureForTypeHandle.
//
// If the owning type is one of the well-known primitive types, then the owning type
// signature ends up being written in "flattened" form (e.g., if the owning type is
// System.String, a single ELEMENT_TYPE_STRING byte is written as the owning type
// signature). This only happens when the ParamMethodSpec describes a generic method
// defined directly on one of the primitive types. Since .NET 4.0, mscorlib has included
// exactly two such methods (System.String::Join<T> and System.String::Concat<T>), and
// contained no such methods prior to .NET 4.0.
//
// In all other cases, ZapSig::GetSignatureForTypeHandle writes the owning type signature
// in a "standard" form which always starts with bytes that match the following grammar:
//
// [ELEMENT_TYPE_MODULE_ZAPSIG {Index}] [ELEMENT_TYPE_GENERICINST] ELEMENT_TYPE_(CLASS|VALUETYPE) {Token}
//
// IBCMerge only supports the standard form. Specifically, if the flattened form is
// ever processed, updateParamSig and remapParamSig are unable to reliably determine
// whether the subsequent method token should be interpreted as a MethodDef or as an
// ibcMethodSpec (because the flattened form "hides" the explicit ELEMENT_TYPE_MODULE_ZAPSIG
// byte that is normally used to determine how to interpret the method token).
//
// Probe the leading bytes of the signature and ignore this ParamMethodSpec if the leading
// bytes prove that the owning type signature was NOT encoded in the standard form.
//
byte[] signature = ((BlobEntry.SignatureEntry)blob).Signature;
bool owningTypeSignatureAppearsToBeEncodedInStandardForm = false;
if (signature.Length >= 2)
{
CorElementType leadingByte = (CorElementType)signature[0];
if ((leadingByte == CorElementType.ELEMENT_TYPE_MODULE_ZAPSIG) ||
(leadingByte == CorElementType.ELEMENT_TYPE_GENERICINST) ||
(leadingByte == CorElementType.ELEMENT_TYPE_CLASS) ||
(leadingByte == CorElementType.ELEMENT_TYPE_VALUETYPE))
{
owningTypeSignatureAppearsToBeEncodedInStandardForm = true;
}
}
if (!owningTypeSignatureAppearsToBeEncodedInStandardForm)
{
ignoredIbcMethodSpecTokens.Add(blob.Token);
ignore = true;
}
}
}
else
{
// We have old V2 IBC data (ignore it)
ignore = true;
}
break;
case BlobType.ExternalNamespaceDef:
case BlobType.ExternalTypeDef:
case BlobType.ExternalSignatureDef:
case BlobType.ExternalMethodDef:
break;
case BlobType.MetadataStringPool:
case BlobType.MetadataGuidPool:
case BlobType.MetadataBlobPool:
case BlobType.MetadataUserStringPool:
// These blob types should not be carried forward.
ignore = true;
break;
}
if (!ignore)
{
blobs.Add(new IBCBlobKey(blob.Token, blob.Type), blob);
}
}
}
return(blobs);
}
public DebuggerValue(Debugger debugger, CorValue value) {
debugger.Dispatcher.VerifyAccess();
this.debugger = debugger;
CorValue = value;
hashCode = value.GetHashCode();
address = value.Address;
size = value.Size;
elementType = (CorElementType)value.ElementType;
vflags = 0;
if (value.IsGeneric)
vflags |= VFlags.Generic;
if (value.IsReference) {
vflags |= VFlags.Reference;
if (value.IsNull)
vflags |= VFlags.Null;
}
if (value.IsHandle)
vflags |= VFlags.Handle;
if (value.IsArray)
vflags |= VFlags.Array;
if (value.IsBox)
vflags |= VFlags.Box;
if (value.IsString)
vflags |= VFlags.String;
if (value.IsObject) {
vflags |= VFlags.Object;
if (value.IsValueClass)
vflags |= VFlags.ValueClass;
}
if (value.IsContext)
vflags |= VFlags.Context;
if (value.IsComObject)
vflags |= VFlags.ComObject;
if (value.IsExceptionObject)
vflags |= VFlags.ExObject;
if (value.IsHeap)
vflags |= VFlags.Heap;
}
/** Returns CorType object for an array of or pointer to the given type */
public CorType GetArrayOrPointerType(CorElementType elementType, int rank, CorType parameterTypes)
{
ICorDebugType ct = null;
uint urank = (uint) rank;
(_ad() as ICorDebugAppDomain2).GetArrayOrPointerType(elementType, urank, parameterTypes.m_type, out ct);
return ct==null?null:new CorType (ct);
}
static byte[] Convert(CorElementType etype, object c)
{
var tc = c == null ? TypeCode.Empty : Type.GetTypeCode(c.GetType());
switch (tc)
{
case TypeCode.Boolean:
if (etype == CorElementType.Boolean)
{
return new byte[1] {
(byte)((bool)c ? 1 : 0)
}
}
;
return(null);
case TypeCode.Char:
if (etype == CorElementType.Char)
{
return(BitConverter.GetBytes((char)c));
}
return(null);
case TypeCode.SByte:
if (etype == CorElementType.I1)
{
return new byte[1] {
(byte)(sbyte)c
}
}
;
return(null);
case TypeCode.Int16:
if (etype == CorElementType.I2)
{
return(BitConverter.GetBytes((short)c));
}
return(null);
case TypeCode.Int32:
if (etype == CorElementType.I4)
{
return(BitConverter.GetBytes((int)c));
}
return(null);
case TypeCode.Int64:
if (etype == CorElementType.I8)
{
return(BitConverter.GetBytes((long)c));
}
return(null);
case TypeCode.Byte:
if (etype == CorElementType.U1)
{
return new byte[1] {
(byte)c
}
}
;
return(null);
case TypeCode.UInt16:
if (etype == CorElementType.U2)
{
return(BitConverter.GetBytes((ushort)c));
}
return(null);
case TypeCode.UInt32:
if (etype == CorElementType.U4)
{
return(BitConverter.GetBytes((uint)c));
}
return(null);
case TypeCode.UInt64:
if (etype == CorElementType.U8)
{
return(BitConverter.GetBytes((ulong)c));
}
return(null);
case TypeCode.Single:
if (etype == CorElementType.R4)
{
return(BitConverter.GetBytes((float)c));
}
return(null);
case TypeCode.Double:
if (etype == CorElementType.R8)
{
return(BitConverter.GetBytes((double)c));
}
return(null);
}
return(null);
}
static ulong? ParseIntegerConstant(CorElementType etype, string c, out string error) {
error = null;
long smin, smax;
ulong max;
switch (etype) {
case CorElementType.Boolean:
smin = 0;
smax = 1;
max = 1;
break;
case CorElementType.I:
if (IntPtr.Size == 4)
goto case CorElementType.I4;
goto case CorElementType.I8;
case CorElementType.U:
case CorElementType.Ptr:
case CorElementType.FnPtr:
if (UIntPtr.Size == 4)
goto case CorElementType.U4;
goto case CorElementType.U8;
case CorElementType.I1:
case CorElementType.U1:
smin = sbyte.MinValue;
smax = sbyte.MaxValue;
max = byte.MaxValue;
break;
case CorElementType.I2:
case CorElementType.U2:
smin = short.MinValue;
smax = short.MaxValue;
max = ushort.MaxValue;
break;
case CorElementType.I4:
case CorElementType.U4:
smin = int.MinValue;
smax = int.MaxValue;
max = uint.MaxValue;
break;
case CorElementType.I8:
case CorElementType.U8:
smin = long.MinValue;
smax = long.MaxValue;
max = ulong.MaxValue;
break;
default:
return null;
}
ulong v = NumberVMUtils.ParseUInt64(c, 0, max, out error);
if (string.IsNullOrEmpty(error))
return v;
v = (ulong)NumberVMUtils.ParseInt64(c, smin, smax, out error);
if (string.IsNullOrEmpty(error))
return v;
return null;
}
int ICorDebugAppDomain2.GetArrayOrPointerType( CorElementType elementType, uint nRank, ICorDebugType pTypeArg, out ICorDebugType ppType )
{
ppType = null;
return Utility.COM_HResults.S_OK;
}
/** Create a Value to use it in a Function Evaluation. */
public CorValue CreateValue(CorElementType type, CorClass managedClass)
{
ICorDebugValue v = null;
m_eval.CreateValue (type, managedClass==null?null:managedClass.m_class, out v);
return (v==null)?null:new CorValue (v);
}
public void ComputeReturnValueTreatment(CorElementType type, TypeHandle thRetType, bool isVarArgMethod, out bool usesRetBuffer, out uint fpReturnSize)
{
usesRetBuffer = false;
fpReturnSize = 0;
switch (type)
{
case CorElementType.ELEMENT_TYPE_TYPEDBYREF:
throw new NotSupportedException();
case CorElementType.ELEMENT_TYPE_R4:
fpReturnSize = sizeof(float);
break;
case CorElementType.ELEMENT_TYPE_R8:
fpReturnSize = sizeof(double);
break;
case CorElementType.ELEMENT_TYPE_VALUETYPE:
{
Debug.Assert(!thRetType.IsNull() && thRetType.IsValueType());
if ((Architecture == TargetArchitecture.X64) && IsX64UnixABI)
{
SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR descriptor;
SystemVStructClassificator.GetSystemVAmd64PassStructInRegisterDescriptor(thRetType.GetRuntimeTypeHandle(), out descriptor);
if (descriptor.passedInRegisters)
{
if (descriptor.eightByteCount == 1)
{
if (descriptor.eightByteClassifications0 == SystemVClassificationType.SystemVClassificationTypeSSE)
{
// Structs occupying just one eightbyte are treated as int / double
fpReturnSize = sizeof(double);
}
}
else
{
// Size of the struct is 16 bytes
fpReturnSize = 16;
// The lowest two bits of the size encode the order of the int and SSE fields
if (descriptor.eightByteClassifications0 == SystemVClassificationType.SystemVClassificationTypeSSE)
{
fpReturnSize += 1;
}
if (descriptor.eightByteClassifications0 == SystemVClassificationType.SystemVClassificationTypeSSE)
{
fpReturnSize += 2;
}
}
break;
}
}
else
{
if (thRetType.IsHomogeneousAggregate() && !isVarArgMethod)
{
int haElementSize = thRetType.GetHomogeneousAggregateElementSize();
fpReturnSize = 4 * (uint)haElementSize;
break;
}
uint size = (uint)thRetType.GetSize();
if (IsX86 || IsX64)
{
// Return value types of size which are not powers of 2 using a RetBuffArg
if ((size & (size - 1)) != 0)
{
usesRetBuffer = true;
break;
}
}
if (size <= EnregisteredReturnTypeIntegerMaxSize)
{
break;
}
}
}
// Value types are returned using return buffer by default
usesRetBuffer = true;
break;
default:
break;
}
}
public Object UnsafeGetValueAsType(CorElementType type)
{
switch(type)
{
case CorElementType.ELEMENT_TYPE_BOOLEAN:
byte bValue=4; // just initialize to avoid compiler warnings
unsafe
{
Debug.Assert(this.Size==sizeof(byte));
this.GetValueInternal(new IntPtr(&bValue));
}
return (object) (bValue!=0);
case CorElementType.ELEMENT_TYPE_CHAR:
char cValue='a'; // initialize to avoid compiler warnings
unsafe
{
Debug.Assert(this.Size==sizeof(char));
this.GetValueInternal(new IntPtr(&cValue));
}
return (object) cValue;
case CorElementType.ELEMENT_TYPE_I1:
SByte i1Value=4;
unsafe
{
Debug.Assert(this.Size==sizeof(SByte));
this.GetValueInternal(new IntPtr(&i1Value));
}
return (object) i1Value;
case CorElementType.ELEMENT_TYPE_U1:
Byte u1Value=4;
unsafe
{
Debug.Assert(this.Size==sizeof(Byte));
this.GetValueInternal(new IntPtr(&u1Value));
}
return (object) u1Value;
case CorElementType.ELEMENT_TYPE_I2:
Int16 i2Value=4;
unsafe
{
Debug.Assert(this.Size==sizeof(Int16));
this.GetValueInternal(new IntPtr(&i2Value));
}
return (object) i2Value;
case CorElementType.ELEMENT_TYPE_U2:
UInt16 u2Value=4;
unsafe
{
Debug.Assert(this.Size==sizeof(UInt16));
this.GetValueInternal(new IntPtr(&u2Value));
}
return (object) u2Value;
case CorElementType.ELEMENT_TYPE_I:
IntPtr ipValue=IntPtr.Zero;
unsafe
{
Debug.Assert(this.Size==sizeof(IntPtr));
this.GetValueInternal(new IntPtr(&ipValue));
}
return (object) ipValue;
case CorElementType.ELEMENT_TYPE_U:
UIntPtr uipValue=UIntPtr.Zero;
unsafe
{
Debug.Assert(this.Size==sizeof(UIntPtr));
this.GetValueInternal(new IntPtr(&uipValue));
}
return (object) uipValue;
case CorElementType.ELEMENT_TYPE_I4:
Int32 i4Value=4;
unsafe
{
Debug.Assert(this.Size==sizeof(Int32));
this.GetValueInternal(new IntPtr(&i4Value));
}
return (object) i4Value;
case CorElementType.ELEMENT_TYPE_U4:
UInt32 u4Value=4;
unsafe
{
Debug.Assert(this.Size==sizeof(UInt32));
this.GetValueInternal(new IntPtr(&u4Value));
}
return (object) u4Value;
case CorElementType.ELEMENT_TYPE_I8:
Int64 i8Value=4;
unsafe
{
Debug.Assert(this.Size==sizeof(Int64));
this.GetValueInternal(new IntPtr(&i8Value));
}
return (object) i8Value;
case CorElementType.ELEMENT_TYPE_U8:
UInt64 u8Value=4;
unsafe
{
Debug.Assert(this.Size==sizeof(UInt64));
this.GetValueInternal(new IntPtr(&u8Value));
}
return (object) u8Value;
case CorElementType.ELEMENT_TYPE_R4:
Single r4Value=4;
unsafe
{
Debug.Assert(this.Size==sizeof(Single));
this.GetValueInternal(new IntPtr(&r4Value));
}
return (object) r4Value;
case CorElementType.ELEMENT_TYPE_R8:
Double r8Value=4;
unsafe
{
Debug.Assert(this.Size==sizeof(Double));
this.GetValueInternal(new IntPtr(&r8Value));
}
return (object) r8Value;
case CorElementType.ELEMENT_TYPE_VALUETYPE:
byte[] buffer = new byte[this.Size];
unsafe
{
fixed (byte* bufferPtr = &buffer[0])
{
Debug.Assert(this.Size == buffer.Length);
this.GetValueInternal( new IntPtr(bufferPtr));
}
}
return buffer;
default:
Debug.Assert(false,"Generic value should not be of any other type");
throw new NotSupportedException();
}
}
// Load type from IBC ZapSig. Returns null for cases where the type is legally defined, but is not used in R2R image generation
private TypeDesc GetSigTypeFromIBCZapSig(IBCModule ibcModule, EcmaModule ecmaModule, BlobReader sig)
{
TypeSystemContext context = ibcModule.EcmaModule.Context;
CorElementType typ = (CorElementType)sig.ReadByte();
switch (typ)
{
case CorElementType.ELEMENT_TYPE_VOID:
return(context.GetWellKnownType(WellKnownType.Void));
case CorElementType.ELEMENT_TYPE_BOOLEAN:
return(context.GetWellKnownType(WellKnownType.Boolean));
case CorElementType.ELEMENT_TYPE_CHAR:
return(context.GetWellKnownType(WellKnownType.Char));
case CorElementType.ELEMENT_TYPE_I:
return(context.GetWellKnownType(WellKnownType.IntPtr));
case CorElementType.ELEMENT_TYPE_U:
return(context.GetWellKnownType(WellKnownType.UIntPtr));
case CorElementType.ELEMENT_TYPE_I1:
return(context.GetWellKnownType(WellKnownType.SByte));
case CorElementType.ELEMENT_TYPE_U1:
return(context.GetWellKnownType(WellKnownType.Byte));
case CorElementType.ELEMENT_TYPE_I2:
return(context.GetWellKnownType(WellKnownType.Int16));
case CorElementType.ELEMENT_TYPE_U2:
return(context.GetWellKnownType(WellKnownType.UInt16));
case CorElementType.ELEMENT_TYPE_I4:
return(context.GetWellKnownType(WellKnownType.Int32));
case CorElementType.ELEMENT_TYPE_U4:
return(context.GetWellKnownType(WellKnownType.UInt32));
case CorElementType.ELEMENT_TYPE_I8:
return(context.GetWellKnownType(WellKnownType.Int64));
case CorElementType.ELEMENT_TYPE_U8:
return(context.GetWellKnownType(WellKnownType.UInt64));
case CorElementType.ELEMENT_TYPE_R4:
return(context.GetWellKnownType(WellKnownType.Single));
case CorElementType.ELEMENT_TYPE_R8:
return(context.GetWellKnownType(WellKnownType.Double));
case CorElementType.ELEMENT_TYPE_STRING:
return(context.GetWellKnownType(WellKnownType.String));
case CorElementType.ELEMENT_TYPE_OBJECT:
return(context.GetWellKnownType(WellKnownType.Object));
case CorElementType.ELEMENT_TYPE_TYPEDBYREF:
return(context.GetWellKnownType(WellKnownType.TypedReference));
case CorElementType.ELEMENT_TYPE_CANON_ZAPSIG:
if (!context.SupportsCanon)
{
return(null);
}
return(context.CanonType);
case CorElementType.ELEMENT_TYPE_MODULE_ZAPSIG:
// If null, then the remote reference is not found. GetSigTypeFromIBCZapSig will search all locations to try and resolve the type
EcmaModule remoteModule = ibcModule.GetModuleFromIndex(sig.ReadCompressedInteger());
return(GetSigTypeFromIBCZapSig(ibcModule, remoteModule, sig));
case CorElementType.ELEMENT_TYPE_VAR:
case CorElementType.ELEMENT_TYPE_MVAR:
// VAR/MVAR can never appear in a ZapSig
throw new Exception("Attempt to parse ELEMENT_TYPE_VAR or ELEMENT_TYPE_MVAR in an IBC ZapSig");
case CorElementType.ELEMENT_TYPE_GENERICINST:
CorElementType genericTyp = (CorElementType)sig.ReadByte();
MetadataType genericDefinitionType = LoadTypeFromIBCZapSig(ibcModule, ecmaModule, genericTyp, ref sig);
if (genericDefinitionType == null)
{
return(null);
}
int numTypeArgs = sig.ReadCompressedInteger();
TypeDesc[] typeArgs = new TypeDesc[numTypeArgs];
for (int i = 0; i < numTypeArgs; i++)
{
TypeDesc nextTypeArg = GetSigTypeFromIBCZapSig(ibcModule, ecmaModule, sig);
if (nextTypeArg == null)
{
return(null);
}
SkipTypeInIBCZapSig(ref sig);
typeArgs[i] = nextTypeArg;
}
return(genericDefinitionType.MakeInstantiatedType(new Instantiation(typeArgs)));
case CorElementType.ELEMENT_TYPE_CLASS:
case CorElementType.ELEMENT_TYPE_VALUETYPE:
return(LoadTypeFromIBCZapSig(ibcModule, ecmaModule, typ, ref sig));
case CorElementType.ELEMENT_TYPE_SZARRAY:
{
TypeDesc arrayElementType = GetSigTypeFromIBCZapSig(ibcModule, ecmaModule, sig);
if (arrayElementType == null)
{
return(null);
}
return(arrayElementType.MakeArrayType());
}
case CorElementType.ELEMENT_TYPE_ARRAY:
{
TypeDesc arrayElementType = GetSigTypeFromIBCZapSig(ibcModule, ecmaModule, sig);
if (arrayElementType == null)
{
return(null);
}
SkipTypeInIBCZapSig(ref sig);
return(arrayElementType.MakeArrayType(sig.ReadCompressedInteger()));
}
case CorElementType.ELEMENT_TYPE_PINNED:
// Return what follows
return(GetSigTypeFromIBCZapSig(ibcModule, ecmaModule, sig));
case CorElementType.ELEMENT_TYPE_BYREF:
{
TypeDesc byRefToType = GetSigTypeFromIBCZapSig(ibcModule, ecmaModule, sig);
if (byRefToType == null)
{
return(null);
}
return(byRefToType.MakeByRefType());
}
case CorElementType.ELEMENT_TYPE_PTR:
{
TypeDesc pointerToType = GetSigTypeFromIBCZapSig(ibcModule, ecmaModule, sig);
if (pointerToType == null)
{
return(null);
}
return(pointerToType.MakePointerType());
}
default:
throw new Exception($"Invalid element type {typ:x} in IBC ZapSig");
}
}
public static unsafe object?GetValue(MetadataImport scope, int token, RuntimeTypeHandle fieldTypeHandle, bool raw)
{
CorElementType corElementType = 0;
long buffer = 0;
int length;
string? stringVal;
stringVal = scope.GetDefaultValue(token, out buffer, out length, out corElementType);
RuntimeType fieldType = fieldTypeHandle.GetRuntimeType();
if (fieldType.IsEnum && raw == false)
{
// NOTE: Unlike in `TypeBuilder.SetConstantValue`, if `fieldType` describes
// a nullable enum type `Nullable<TEnum>`, we do not unpack it to `TEnum` to
// successfully enter this `if` clause. Default values of `TEnum?`-typed
// parameters have been reported as values of the underlying type, changing
// this now might be a breaking change.
long defaultValue = 0;
switch (corElementType)
{
#region Switch
case CorElementType.ELEMENT_TYPE_VOID:
return(DBNull.Value);
case CorElementType.ELEMENT_TYPE_CHAR:
defaultValue = *(char *)&buffer;
break;
case CorElementType.ELEMENT_TYPE_I1:
defaultValue = *(sbyte *)&buffer;
break;
case CorElementType.ELEMENT_TYPE_U1:
defaultValue = *(byte *)&buffer;
break;
case CorElementType.ELEMENT_TYPE_I2:
defaultValue = *(short *)&buffer;
break;
case CorElementType.ELEMENT_TYPE_U2:
defaultValue = *(ushort *)&buffer;
break;
case CorElementType.ELEMENT_TYPE_I4:
defaultValue = *(int *)&buffer;
break;
case CorElementType.ELEMENT_TYPE_U4:
defaultValue = *(uint *)&buffer;
break;
case CorElementType.ELEMENT_TYPE_I8:
defaultValue = buffer;
break;
case CorElementType.ELEMENT_TYPE_U8:
defaultValue = buffer;
break;
case CorElementType.ELEMENT_TYPE_CLASS:
return(null);
default:
throw new FormatException(SR.Arg_BadLiteralFormat);
#endregion
}
return(RuntimeType.CreateEnum(fieldType, defaultValue));
}
else if (fieldType == typeof(DateTime))
{
long defaultValue = 0;
switch (corElementType)
{
#region Switch
case CorElementType.ELEMENT_TYPE_VOID:
return(DBNull.Value);
case CorElementType.ELEMENT_TYPE_I8:
defaultValue = buffer;
break;
case CorElementType.ELEMENT_TYPE_U8:
defaultValue = buffer;
break;
case CorElementType.ELEMENT_TYPE_CLASS:
return(null);
default:
throw new FormatException(SR.Arg_BadLiteralFormat);
#endregion
}
return(new DateTime(defaultValue));
}
else
{
return(corElementType switch
{
CorElementType.ELEMENT_TYPE_VOID => DBNull.Value,
CorElementType.ELEMENT_TYPE_CHAR => *(char *)&buffer,
CorElementType.ELEMENT_TYPE_I1 => *(sbyte *)&buffer,
CorElementType.ELEMENT_TYPE_U1 => *(byte *)&buffer,
CorElementType.ELEMENT_TYPE_I2 => *(short *)&buffer,
CorElementType.ELEMENT_TYPE_U2 => *(ushort *)&buffer,
CorElementType.ELEMENT_TYPE_I4 => *(int *)&buffer,
CorElementType.ELEMENT_TYPE_U4 => *(uint *)&buffer,
CorElementType.ELEMENT_TYPE_I8 => buffer,
CorElementType.ELEMENT_TYPE_U8 => (ulong)buffer,
CorElementType.ELEMENT_TYPE_BOOLEAN => (*(int *)&buffer != 0),
CorElementType.ELEMENT_TYPE_R4 => *(float *)&buffer,
CorElementType.ELEMENT_TYPE_R8 => *(double *)&buffer,
CorElementType.ELEMENT_TYPE_STRING => stringVal ?? string.Empty,
CorElementType.ELEMENT_TYPE_CLASS => null,
_ => throw new FormatException(SR.Arg_BadLiteralFormat),
});
static object ConvertUInt64(CorElementType etype, ulong v) {
switch (etype) {
case CorElementType.Boolean:
return v != 0;
case CorElementType.I:
if (IntPtr.Size == 4)
goto case CorElementType.I4;
goto case CorElementType.I8;
case CorElementType.I1: return (sbyte)v;
case CorElementType.I2: return (short)v;
case CorElementType.I4: return (int)v;
case CorElementType.I8: return (long)v;
case CorElementType.U:
if (UIntPtr.Size == 4)
goto case CorElementType.U4;
goto case CorElementType.U8;
case CorElementType.U1: return (byte)v;
case CorElementType.U2: return (ushort)v;
case CorElementType.U4: return (uint)v;
case CorElementType.U8: return v;
}
return null;
}
private static void SkipTypeInIBCZapSig(ref BlobReader sig)
{
CorElementType typ = (CorElementType)sig.ReadByte();
switch (typ)
{
case CorElementType.ELEMENT_TYPE_VOID:
case CorElementType.ELEMENT_TYPE_BOOLEAN:
case CorElementType.ELEMENT_TYPE_CHAR:
case CorElementType.ELEMENT_TYPE_I:
case CorElementType.ELEMENT_TYPE_U:
case CorElementType.ELEMENT_TYPE_I1:
case CorElementType.ELEMENT_TYPE_U1:
case CorElementType.ELEMENT_TYPE_I2:
case CorElementType.ELEMENT_TYPE_U2:
case CorElementType.ELEMENT_TYPE_I4:
case CorElementType.ELEMENT_TYPE_U4:
case CorElementType.ELEMENT_TYPE_I8:
case CorElementType.ELEMENT_TYPE_U8:
case CorElementType.ELEMENT_TYPE_R4:
case CorElementType.ELEMENT_TYPE_R8:
case CorElementType.ELEMENT_TYPE_STRING:
case CorElementType.ELEMENT_TYPE_OBJECT:
case CorElementType.ELEMENT_TYPE_TYPEDBYREF:
return;
case CorElementType.ELEMENT_TYPE_CANON_ZAPSIG:
return;
case CorElementType.ELEMENT_TYPE_MODULE_ZAPSIG:
sig.ReadCompressedInteger();
SkipTypeInIBCZapSig(ref sig);
return;
case CorElementType.ELEMENT_TYPE_VAR:
case CorElementType.ELEMENT_TYPE_MVAR:
// VAR/MVAR can never appear in a ZapSig
throw new Exception("Attempt to parse ELEMENT_TYPE_VAR or ELEMENT_TYPE_MVAR in an IBC ZapSig");
case CorElementType.ELEMENT_TYPE_GENERICINST:
sig.ReadByte();
sig.ReadTypeHandle();
int numTypeArgs = sig.ReadCompressedInteger();
for (int i = 0; i < numTypeArgs; i++)
{
SkipTypeInIBCZapSig(ref sig);
}
return;
case CorElementType.ELEMENT_TYPE_CLASS:
case CorElementType.ELEMENT_TYPE_VALUETYPE:
sig.ReadTypeHandle();
return;
case CorElementType.ELEMENT_TYPE_SZARRAY:
SkipTypeInIBCZapSig(ref sig);
return;
case CorElementType.ELEMENT_TYPE_ARRAY:
SkipTypeInIBCZapSig(ref sig);
sig.ReadCompressedInteger(); // rank
int numSizes = sig.ReadCompressedInteger();
for (int i = 0; i < numSizes; i++)
{
sig.ReadCompressedInteger();
}
int numLoBounds = sig.ReadCompressedInteger();
for (int i = 0; i < numLoBounds; i++)
{
sig.ReadCompressedInteger();
}
return;
case CorElementType.ELEMENT_TYPE_PINNED:
case CorElementType.ELEMENT_TYPE_BYREF:
case CorElementType.ELEMENT_TYPE_PTR:
SkipTypeInIBCZapSig(ref sig);
return;
default:
throw new Exception($"Invalid element type {typ:x} in IBC ZapSig");
}
}
static byte[] Convert(CorElementType etype, object c) {
var tc = c == null ? TypeCode.Empty : Type.GetTypeCode(c.GetType());
switch (tc) {
case TypeCode.Boolean:
if (etype == CorElementType.Boolean)
return new byte[1] { (byte)((bool)c ? 1 : 0) };
return null;
case TypeCode.Char:
if (etype == CorElementType.Char)
return BitConverter.GetBytes((char)c);
return null;
case TypeCode.SByte:
if (etype == CorElementType.I1)
return new byte[1] { (byte)(sbyte)c };
return null;
case TypeCode.Int16:
if (etype == CorElementType.I2)
return BitConverter.GetBytes((short)c);
return null;
case TypeCode.Int32:
if (etype == CorElementType.I4)
return BitConverter.GetBytes((int)c);
return null;
case TypeCode.Int64:
if (etype == CorElementType.I8)
return BitConverter.GetBytes((long)c);
return null;
case TypeCode.Byte:
if (etype == CorElementType.U1)
return new byte[1] { (byte)c };
return null;
case TypeCode.UInt16:
if (etype == CorElementType.U2)
return BitConverter.GetBytes((ushort)c);
return null;
case TypeCode.UInt32:
if (etype == CorElementType.U4)
return BitConverter.GetBytes((uint)c);
return null;
case TypeCode.UInt64:
if (etype == CorElementType.U8)
return BitConverter.GetBytes((ulong)c);
return null;
case TypeCode.Single:
if (etype == CorElementType.R4)
return BitConverter.GetBytes((float)c);
return null;
case TypeCode.Double:
if (etype == CorElementType.R8)
return BitConverter.GetBytes((double)c);
return null;
}
return null;
}
private MetadataType LoadTypeFromIBCZapSig(IBCModule ibcModule, EcmaModule ecmaModule, CorElementType typ, ref BlobReader sig)
{
switch (typ)
{
case CorElementType.ELEMENT_TYPE_CLASS:
case CorElementType.ELEMENT_TYPE_VALUETYPE:
uint token = (uint)ibcModule.EcmaModule.MetadataReader.GetToken(sig.ReadTypeHandle());
if (ecmaModule != ibcModule.EcmaModule)
{
// ibcExternalType tokens are actually encoded as mdtTypeDef tokens in the signature
uint rid = Cor.Macros.RidFromToken(token);
uint ibcToken = Cor.Macros.TokenFromRid(rid, CorTokenType.ibcExternalType);
token = LookupIbcTypeToken(ref ecmaModule, ibcToken, ibcModule.Blobs);
}
switch (Cor.Macros.TypeFromToken(token))
{
case CorTokenType.mdtTypeDef:
case CorTokenType.mdtTypeRef:
// success
break;
default:
throw new Exception("Invalid token found while parsing IBC ZapSig generic instantiation");
}
if (Cor.Macros.IsNilToken(token))
{
return(null);
}
var result = (MetadataType)ecmaModule.GetType(MetadataTokens.EntityHandle((int)token));
if ((typ == CorElementType.ELEMENT_TYPE_VALUETYPE) != result.IsValueType)
{
throw new Exception("Mismatch between valuetype and reference type in while parsing generic instantiation");
}
return(result);
default:
throw new Exception("Unexpected token type parsing ELEMENT_TYPE_GENERICINST");
}
}
public void NewArray(CorElementType type, CorClass managedClass, int rank,
int dimensions, int lowBounds)
{
uint udims = (uint)dimensions;
uint ulowBounds = (uint)lowBounds;
m_eval.NewArray (type, managedClass.m_class, (uint)rank, ref udims, ref ulowBounds);
}
internal static bool IsByRef(RuntimeType type)
{
CorElementType corElemType = GetCorElementType(type);
return(corElemType == CorElementType.ByRef);
}
protected RuntimeValue( Engine eng, WireProtocol.Commands.Debugging_Value handle )
{
m_eng = eng;
m_handle = handle;
switch((RuntimeDataType)handle.m_dt)
{
case RuntimeDataType.DATATYPE_BOOLEAN : m_corElementType = CorElementType.ELEMENT_TYPE_BOOLEAN; break;
case RuntimeDataType.DATATYPE_I1 : m_corElementType = CorElementType.ELEMENT_TYPE_I1; break;
case RuntimeDataType.DATATYPE_U1 : m_corElementType = CorElementType.ELEMENT_TYPE_U1; break;
case RuntimeDataType.DATATYPE_CHAR : m_corElementType = CorElementType.ELEMENT_TYPE_CHAR; break;
case RuntimeDataType.DATATYPE_I2 : m_corElementType = CorElementType.ELEMENT_TYPE_I2; break;
case RuntimeDataType.DATATYPE_U2 : m_corElementType = CorElementType.ELEMENT_TYPE_U2; break;
case RuntimeDataType.DATATYPE_I4 : m_corElementType = CorElementType.ELEMENT_TYPE_I4; break;
case RuntimeDataType.DATATYPE_U4 : m_corElementType = CorElementType.ELEMENT_TYPE_U4; break;
case RuntimeDataType.DATATYPE_R4 : m_corElementType = CorElementType.ELEMENT_TYPE_R4; break;
case RuntimeDataType.DATATYPE_I8 : m_corElementType = CorElementType.ELEMENT_TYPE_I8; break;
case RuntimeDataType.DATATYPE_U8 : m_corElementType = CorElementType.ELEMENT_TYPE_U8; break;
case RuntimeDataType.DATATYPE_R8 : m_corElementType = CorElementType.ELEMENT_TYPE_R8; break;
case RuntimeDataType.DATATYPE_DATETIME : m_corElementType = CorElementType.ELEMENT_TYPE_VALUETYPE; break;
case RuntimeDataType.DATATYPE_TIMESPAN : m_corElementType = CorElementType.ELEMENT_TYPE_VALUETYPE; break;
case RuntimeDataType.DATATYPE_STRING : m_corElementType = CorElementType.ELEMENT_TYPE_STRING; break;
case RuntimeDataType.DATATYPE_OBJECT : m_corElementType = CorElementType.ELEMENT_TYPE_OBJECT; break;
case RuntimeDataType.DATATYPE_BYREF : m_corElementType = CorElementType.ELEMENT_TYPE_BYREF; break;
case RuntimeDataType.DATATYPE_ARRAY_BYREF : m_corElementType = CorElementType.ELEMENT_TYPE_BYREF; break;
case RuntimeDataType.DATATYPE_CLASS : m_corElementType = CorElementType.ELEMENT_TYPE_CLASS; break;
case RuntimeDataType.DATATYPE_VALUETYPE : m_corElementType = CorElementType.ELEMENT_TYPE_VALUETYPE; break;
case RuntimeDataType.DATATYPE_SZARRAY : m_corElementType = CorElementType.ELEMENT_TYPE_SZARRAY; break;
case RuntimeDataType.DATATYPE_REFLECTION : m_corElementType = CorElementType.ELEMENT_TYPE_CLASS; break;
case RuntimeDataType.DATATYPE_DELEGATE_HEAD : m_corElementType = CorElementType.ELEMENT_TYPE_CLASS; break;
case RuntimeDataType.DATATYPE_DELEGATELIST_HEAD : m_corElementType = CorElementType.ELEMENT_TYPE_CLASS; break;
case RuntimeDataType.DATATYPE_WEAKCLASS : m_corElementType = CorElementType.ELEMENT_TYPE_CLASS; break;
case RuntimeDataType.DATATYPE_TRANSPARENT_PROXY : m_corElementType = CorElementType.ELEMENT_TYPE_CLASS; break;
}
}
internal static bool IsPointer(RuntimeType type)
{
CorElementType corElemType = GetCorElementType(type);
return(corElemType == CorElementType.Ptr);
}
unsafe static object ReadConstant(IntPtr addr, uint size, CorElementType elementType) {
byte* p = (byte*)addr;
if (p == null)
return null;
// size is always 0 unless it's a string...
switch (elementType) {
case CorElementType.Boolean: return *p != 0;
case CorElementType.Char: return *(char*)p;
case CorElementType.I1: return *(sbyte*)p;
case CorElementType.U1: return *p;
case CorElementType.I2: return *(short*)p;
case CorElementType.U2: return *(ushort*)p;
case CorElementType.I4: return *(int*)p;
case CorElementType.U4: return *(uint*)p;
case CorElementType.I8: return *(long*)p;
case CorElementType.U8: return *(ulong*)p;
case CorElementType.R4: return *(float*)p;
case CorElementType.R8: return *(double*)p;
case CorElementType.String: return new string((char*)p, 0, (int)size);
default: return null;
}
}
internal static bool IsSzArray(RuntimeType type)
{
CorElementType corElemType = GetCorElementType(type);
return(corElemType == CorElementType.SzArray);
}
private unsafe static int GetIntegralTypeMatchSize(CorElementType corType)
{
switch (corType)
{
case CorElementType.ELEMENT_TYPE_I1:
case CorElementType.ELEMENT_TYPE_U1:
return 1;
case CorElementType.ELEMENT_TYPE_I2:
case CorElementType.ELEMENT_TYPE_U2:
return 2;
case CorElementType.ELEMENT_TYPE_I4:
case CorElementType.ELEMENT_TYPE_U4:
return 4;
case CorElementType.ELEMENT_TYPE_I8:
case CorElementType.ELEMENT_TYPE_U8:
return 8;
case CorElementType.ELEMENT_TYPE_I:
case CorElementType.ELEMENT_TYPE_U:
return sizeof(IntPtr);
default:
return 0;
}
}
public CorDebugGenericType(CorElementType elemType, RuntimeValue rtv, CorDebugAppDomain appDomain)
{
m_elemType = elemType;
m_rtv = rtv;
m_appDomain = appDomain;
}
