Merge pull request #1764 from JetBrains/corDebugElementTypes

Handle some other COR_ELEMENT_TYPES to avoid exceptions in ReadType

Author: DavidKarlas

CorApi/ICorDebugWrappers.cs

@@ -156,8 +156,8 @@ public enum CorDebugUserState
         USER_UNSAFE_POINT      = 0x80        
     }
 
-	// [Xamarin] Expression evaluator.
-    [CLSCompliant(true)]
+    // [Xamarin] Expression evaluator.
+    [CLSCompliant (true)]
     [Flags]
     public enum CorElementType
     {
@@ -171,7 +171,7 @@ public enum CorElementType
         ELEMENT_TYPE_CMOD_REQD = 0x1f,
         ELEMENT_TYPE_END = 0,
         ELEMENT_TYPE_FNPTR = 0x1b,
-		ELEMENT_TYPE_GENERICINST = 0x15,
+        ELEMENT_TYPE_GENERICINST = 0x15,
         ELEMENT_TYPE_I = 0x18,
         ELEMENT_TYPE_I1 = 4,
         ELEMENT_TYPE_I2 = 6,
@@ -180,13 +180,13 @@ public enum CorElementType
         ELEMENT_TYPE_INTERNAL = 0x21,
         ELEMENT_TYPE_MAX = 0x22,
         ELEMENT_TYPE_MODIFIER = 0x40,
-		ELEMENT_TYPE_MVAR = 0x1e,
+        ELEMENT_TYPE_MVAR = 0x1e,
         ELEMENT_TYPE_OBJECT = 0x1c,
-        ELEMENT_TYPE_PINNED = 0x45,
+        ELEMENT_TYPE_PINNED = 0x05 | ELEMENT_TYPE_MODIFIER,
         ELEMENT_TYPE_PTR = 15,
         ELEMENT_TYPE_R4 = 12,
         ELEMENT_TYPE_R8 = 13,
-        ELEMENT_TYPE_SENTINEL = 0x41,
+        ELEMENT_TYPE_SENTINEL = 0x01 | ELEMENT_TYPE_MODIFIER,
         ELEMENT_TYPE_STRING = 14,
         ELEMENT_TYPE_SZARRAY = 0x1d,
         ELEMENT_TYPE_TYPEDBYREF = 0x16,
@@ -196,8 +196,37 @@ public enum CorElementType
         ELEMENT_TYPE_U4 = 9,
         ELEMENT_TYPE_U8 = 11,
         ELEMENT_TYPE_VALUETYPE = 0x11,
-		ELEMENT_TYPE_VAR = 0x13,
-        ELEMENT_TYPE_VOID = 1
+        ELEMENT_TYPE_VAR = 0x13,
+        ELEMENT_TYPE_VOID = 1,
+
+
+        // from corpriv.h (CoreCLR sources)
+
+        // ZAPSIG types
+        // ZapSig encoding for ELEMENT_TYPE_VAR and ELEMENT_TYPE_MVAR. It is always followed
+        // by the RID of a GenericParam token, encoded as a compressed integer.
+        ELEMENT_TYPE_VAR_ZAPSIG = 0x3b,
+
+        // ZapSig encoding for an array MethodTable to allow it to remain such after decoding
+        // (rather than being transformed into the TypeHandle representing that array)
+        //
+        // The element is always followed by ELEMENT_TYPE_SZARRAY or ELEMENT_TYPE_ARRAY
+        ELEMENT_TYPE_NATIVE_ARRAY_TEMPLATE_ZAPSIG = 0x3c,
+
+        // ZapSig encoding for native value types in IL stubs. IL stub signatures may contain
+        // ELEMENT_TYPE_INTERNAL followed by ParamTypeDesc with ELEMENT_TYPE_VALUETYPE element
+        // type. It acts like a modifier to the underlying structure making it look like its
+        // unmanaged view (size determined by unmanaged layout, blittable, no GC pointers).
+        //
+        // ELEMENT_TYPE_NATIVE_VALUETYPE_ZAPSIG is used when encoding such types to NGEN images.
+        // The signature looks like this: ET_NATIVE_VALUETYPE_ZAPSIG ET_VALUETYPE <token>.
+        // See code:ZapSig.GetSignatureForTypeHandle and code:SigPointer.GetTypeHandleThrowing
+        // where the encoding/decoding takes place.
+        ELEMENT_TYPE_NATIVE_VALUETYPE_ZAPSIG = 0x3d,
+
+        ELEMENT_TYPE_CANON_ZAPSIG = 0x3e, // zapsig encoding for [mscorlib]System.__Canon
+        ELEMENT_TYPE_MODULE_ZAPSIG = 0x3f, // zapsig encoding for external module id#
+
     }
 
     #region Top-level interfaces

CorApi2/Extensions/MetadataExtensions.cs

@@ -136,12 +136,13 @@ static MetadataHelperFunctionsExtensions ()
 			CoreTypes.Add (CorElementType.ELEMENT_TYPE_U, typeof (UIntPtr));
 		}
 
-		internal static void ReadMethodSignature (IMetadataImport importer, Instantiation instantiation, ref IntPtr pData, out CorCallingConvention cconv, out Type retType, out List<Type> argTypes)
+		internal static void ReadMethodSignature (IMetadataImport importer, Instantiation instantiation, ref IntPtr pData, out CorCallingConvention cconv, out Type retType, out List<Type> argTypes, out int sentinelIndex)
 		{
 			cconv = MetadataHelperFunctions.CorSigUncompressCallingConv (ref pData);
 			uint numArgs = 0;
 			// FIXME: Use number of <T>s.
 			uint types = 0;
+			sentinelIndex = -1;
 			if ((cconv & CorCallingConvention.Generic) == CorCallingConvention.Generic)
 				types = MetadataHelperFunctions.CorSigUncompressData (ref pData);
 
@@ -150,8 +151,25 @@ internal static void ReadMethodSignature (IMetadataImport importer, Instantiatio
 
 			retType = ReadType (importer, instantiation, ref pData);
 			argTypes = new List<Type> ();
-			for (int n = 0; n < numArgs; n++)
+			for (int n = 0; n < numArgs; n++) {
+				CorElementType elemType;
+				unsafe {
+					var pByte = (byte*) pData;
+					var b = *pByte;
+					elemType = (CorElementType) b;
+
+					if (elemType == CorElementType.ELEMENT_TYPE_SENTINEL) {
+						// the case when SENTINEL is presented in a separate position, so we have to increment the pointer
+						sentinelIndex = n;
+						pData = (IntPtr) (pByte + 1);
+					}
+					else if ((elemType & CorElementType.ELEMENT_TYPE_SENTINEL) == CorElementType.ELEMENT_TYPE_SENTINEL) {
+						// SENTINEL is just a flag on element type, so we haven't to promote the pointer
+						sentinelIndex = n;
+					}
+				}
 				argTypes.Add (ReadType (importer, instantiation, ref pData));
+			}
 		}
 
 		static Type ReadType (IMetadataImport importer, Instantiation instantiation, ref IntPtr pData)
@@ -163,6 +181,10 @@ static Type ReadType (IMetadataImport importer, Instantiation instantiation, ref
 				pData = (IntPtr) (pBytes + 1);
 			}
 
+			if ((et & CorElementType.ELEMENT_TYPE_SENTINEL) == CorElementType.ELEMENT_TYPE_SENTINEL) {
+				et ^= CorElementType.ELEMENT_TYPE_SENTINEL; // substract SENTINEL bits from element type to get clean ET
+			}
+
 			switch (et)
 			{
 			case CorElementType.ELEMENT_TYPE_VOID: return typeof (void);
@@ -252,13 +274,26 @@ static Type ReadType (IMetadataImport importer, Instantiation instantiation, ref
 					CorCallingConvention cconv;
 					Type retType;
 					List<Type> argTypes;
-					ReadMethodSignature (importer, instantiation, ref pData, out cconv, out retType, out argTypes);
+					int sentinelIndex;
+					ReadMethodSignature (importer, instantiation, ref pData, out cconv, out retType, out argTypes, out sentinelIndex);
 					return MetadataExtensions.MakeDelegate (retType, argTypes);
 				}
 
 			case CorElementType.ELEMENT_TYPE_CMOD_REQD:
-			case CorElementType.ELEMENT_TYPE_CMOD_OPT:
+			case CorElementType.ELEMENT_TYPE_CMOD_OPT: {
+					uint token = MetadataHelperFunctions.CorSigUncompressToken (ref pData);
+					return new MetadataType (importer, (int) token);
+				}
+
+			case CorElementType.ELEMENT_TYPE_INTERNAL:
+				return typeof(object); // hack to avoid the exceptions. CLR spec says that this type should never occurs, but it occurs sometimes, mystics
+
+			case CorElementType.ELEMENT_TYPE_NATIVE_ARRAY_TEMPLATE_ZAPSIG:
+			case CorElementType.ELEMENT_TYPE_NATIVE_VALUETYPE_ZAPSIG:
 				return ReadType (importer, instantiation, ref pData);
+
+			case CorElementType.ELEMENT_TYPE_CANON_ZAPSIG:
+				return typeof(object); // this is representation of __Canon type, but it's inaccessible, using object instead
 			}
 			throw new NotSupportedException ("Unknown sig element type: " + et);
 		}

CorApi2/Metadata/CorMetadata.cs

@@ -304,7 +304,7 @@ internal MetadataMethodInfo(IMetadataImport importer, int methodToken, Instantia
 
 			// [Xamarin] Expression evaluator.
 			CorCallingConvention callingConv;
-			MetadataHelperFunctionsExtensions.ReadMethodSignature (importer, instantiation, ref ppvSigBlob, out callingConv, out m_retType, out m_argTypes);
+            MetadataHelperFunctionsExtensions.ReadMethodSignature (importer, instantiation, ref ppvSigBlob, out callingConv, out m_retType, out m_argTypes, out m_sentinelIndex);
             m_name = szMethodName.ToString();
             m_methodAttributes = (MethodAttributes)pdwAttr;
         }
@@ -456,15 +456,24 @@ public string[] GetGenericArgumentNames()
             return MetadataHelperFunctions.GetGenericArgumentNames(m_importer,m_methodToken);
         }
 
+        public int VarargStartIndex
+        {
+            get
+            {
+                return m_sentinelIndex;
+            }
+        }
+
         private IMetadataImport m_importer;
         private string m_name;
         private int m_classToken;
         private int m_methodToken;
         private MethodAttributes m_methodAttributes;
-		// [Xamarin] Expression evaluator.
-		private List<Type> m_argTypes;
-		private Type m_retType;
-		private object[] m_customAttributes;
+        // [Xamarin] Expression evaluator.
+        private List<Type> m_argTypes;
+        private Type m_retType;
+        private object[] m_customAttributes;
+        private int m_sentinelIndex;
     }
 
     public enum MetadataTokenType