Implementation for UnsafeAccessorTypeAttribute

src/coreclr/dlls/mscorrc/mscorrc.rc

@@ -596,6 +596,8 @@ BEGIN
         BFA_BAD_FIELD_TOKEN                     "Field token out of range."
         BFA_INVALID_FIELD_ACC_FLAGS             "Invalid Field Access Flags."
         BFA_INVALID_UNSAFEACCESSOR              "Invalid usage of UnsafeAccessorAttribute."
+        BFA_INVALID_UNSAFEACCESSORTYPE          "Invalid usage of UnsafeAccessorTypeAttribute."
+        BFA_INVALID_UNSAFEACCESSORTYPE_VALUETYPE "ValueTypes are not supported with UnsafeAccessorTypeAttribute."
         BFA_FIELD_LITERAL_AND_INIT              "Field is Literal and InitOnly."
         BFA_NONSTATIC_GLOBAL_FIELD              "Non-Static Global Field."
         BFA_INSTANCE_FIELD_IN_INT               "Instance Field in an Interface."

src/coreclr/dlls/mscorrc/resource.h

@@ -415,10 +415,11 @@
 #define BFA_BAD_TYPEREF_TOKEN                   0x2046
 #define BFA_BAD_CLASS_INT_CA_FORMAT             0x2048
 #define BFA_BAD_COMPLUS_SIG                     0x2049
-#define BFA_BAD_ELEM_IN_SIZEOF                  0x204b
-#define BFA_IJW_IN_COLLECTIBLE_ALC              0x204c
-#define BFA_INVALID_UNSAFEACCESSOR              0x204d
-
+#define BFA_BAD_ELEM_IN_SIZEOF                  0x204a
+#define BFA_IJW_IN_COLLECTIBLE_ALC              0x204b
+#define BFA_INVALID_UNSAFEACCESSOR              0x204c
+#define BFA_INVALID_UNSAFEACCESSORTYPE          0x204d
+#define BFA_INVALID_UNSAFEACCESSORTYPE_VALUETYPE 0x204e
 #define IDS_CLASSLOAD_INTERFACE_NO_ACCESS       0x204f
 
 #define BFA_BAD_CA_HEADER                       0x2050

src/coreclr/vm/siginfo.cpp

@@ -387,6 +387,50 @@ void SigPointer::ConvertToInternalSignature(Module* pSigModule, SigTypeContext *
     }
 }
 
+void SigPointer::CopyModOptsReqs(SigBuilder * pSigBuilder)
+{
+    CONTRACTL
+    {
+        INSTANCE_CHECK;
+        STANDARD_VM_CHECK;
+    }
+    CONTRACTL_END
+
+    CorElementType typ;
+    IfFailThrow(PeekElemType(&typ));
+    while (typ == ELEMENT_TYPE_CMOD_REQD || typ == ELEMENT_TYPE_CMOD_OPT)
+    {
+        // Skip the custom modifier
+        IfFailThrow(GetByte(NULL));
+
+        // Get the encoded token.
+        uint32_t token;
+        IfFailThrow(GetToken(&token));
+
+        // Append the custom modifier and encoded token to the signature.
+        pSigBuilder->AppendElementType(typ);
+        pSigBuilder->AppendToken(token);
+
+        typ = ELEMENT_TYPE_END;
+        IfFailThrow(PeekElemType(&typ));
+    }
+}
+
+void SigPointer::CopyExactlyOne(SigBuilder* pSigBuilder)
+{
+    CONTRACTL
+    {
+        INSTANCE_CHECK;
+        STANDARD_VM_CHECK;
+    }
+    CONTRACTL_END
+
+    intptr_t beginExactlyOne = (intptr_t)m_ptr;
+    IfFailThrow(SkipExactlyOne());
+    intptr_t endExactlyOne = (intptr_t)m_ptr;
+    pSigBuilder->AppendBlob((const PVOID)(beginExactlyOne), endExactlyOne - beginExactlyOne);
+}
+
 void SigPointer::CopySignature(Module* pSigModule, SigBuilder* pSigBuilder, BYTE additionalCallConv)
 {
     CONTRACTL
@@ -3908,6 +3952,38 @@ MetaSig::CompareElementType(
 
                     return (hInternal == hOtherType);
                 }
+                case ELEMENT_TYPE_GENERICINST:
+                {
+                    // Due to how SigPointer works, we need to fiddle with the signature pointer
+                    // to get the ELEMENT_TYPE_GENERICINST element type back in the stream.
+                    // Since we know the size of the element type, we can just subtract one byte from the
+                    // signature pointer to get the correct value.
+                    PCCOR_SIGNATURE genericInstSig;
+                    uint32_t genericInstSigLen;
+                    if (Type1 == ELEMENT_TYPE_INTERNAL)
+                    {
+                        const BYTE* sigRaw = (const BYTE*)pSig2;
+                        genericInstSig = (PCCOR_SIGNATURE)(sigRaw - 1);
+                        genericInstSigLen = (uint32_t)((intptr_t)pEndSig2 - (intptr_t)genericInstSig);
+                    }
+                    else
+                    {
+                        const BYTE* sigRaw = (const BYTE*)pSig1;
+                        genericInstSig = (PCCOR_SIGNATURE)(sigRaw - 1);
+                        genericInstSigLen = (uint32_t)((intptr_t)pEndSig1 - (intptr_t)genericInstSig);
+                    }
+                    // Assert we are in the same state as before.
+                    _ASSERTE(*genericInstSig == ELEMENT_TYPE_GENERICINST);
+
+                    SigPointer inst{ genericInstSig, genericInstSigLen };
+
+                    SigTypeContext dummyContext;
+                    TypeHandle hOtherType = inst.GetTypeHandleThrowing(
+                        pOtherModule,
+                        &dummyContext);
+
+                    return (hInternal == hOtherType);
+                }
                 default:
                 {
                     return FALSE;

src/coreclr/vm/siginfo.hpp

@@ -129,6 +129,8 @@ class SigPointer : public SigParser
 
         void ConvertToInternalExactlyOne(Module* pSigModule, SigTypeContext *pTypeContext, SigBuilder * pSigBuilder, BOOL bSkipCustomModifier = TRUE);
         void ConvertToInternalSignature(Module* pSigModule, SigTypeContext *pTypeContext, SigBuilder * pSigBuilder, BOOL bSkipCustomModifier = TRUE);
+        void CopyModOptsReqs(SigBuilder * pSigBuilder);
+        void CopyExactlyOne(SigBuilder * pSigBuilder);
         void CopySignature(Module* pSigModule, SigBuilder * pSigBuilder, BYTE additionalCallConv);
 
     //=========================================================================