Implement MVP part of const generics for CoreCLR

src/coreclr/ilasm/asmparse.h

@@ -315,6 +315,7 @@ class AsmParse : public ErrorReporter
     friend int ProcessEOF();
     friend unsigned __int8* skipType(unsigned __int8* ptr, BOOL fFixupType);
     friend void FixupConstraints();
+    friend void ResolveTyParList(TyParList* list);
 
 	Assembler* assem;			// This does most of the semantic processing
     bool success;               // overall success of the compilation

src/coreclr/ilasm/asmparse.y

@@ -146,13 +146,14 @@
         /* nonTerminals */
 %type <string> dottedName id methodName atOpt slashedName
 %type <labels> labels
-%type <int32> callConv callKind int32 customHead customHeadWithOwner vtfixupAttr paramAttr ddItemCount variantType repeatOpt truefalse typarAttrib typarAttribs
+%type <int32> callConv callKind int32 customHead customHeadWithOwner vtfixupAttr paramAttr ddItemCount variantType repeatOpt truefalse typarAttrib typarAttribs conTyparAttrib conTyparAttribs
 %type <int32> iidParamIndex genArity genArityNotEmpty
 %type <float64> float64
 %type <int64> int64
 %type <binstr> sigArgs0 sigArgs1 sigArg type bound bounds1 bytes hexbytes nativeType marshalBlob initOpt compQstring caValue
 %type <binstr> marshalClause
 %type <binstr> fieldInit serInit fieldSerInit
+%type <binstr> constTypeArg
 %type <binstr> f32seq f64seq i8seq i16seq i32seq i64seq boolSeq sqstringSeq classSeq objSeq
 %type <binstr> simpleType
 %type <binstr> tyArgs0 tyArgs1 tyArgs2 typeList typeListNotEmpty tyBound
@@ -479,7 +480,7 @@ typeListNotEmpty        : typeSpec                          { $$ = new BinStr();
                         ;
 
 typarsClause            : /* EMPTY */                       { $$ = NULL; PASM->m_TyParList = NULL;}
-                        | '<' typars '>'                    { $$ = $2;   PASM->m_TyParList = $2;}
+                        | '<' typars '>'                    { PASM->m_TyParList = $2; ResolveTyParList(PASM->m_TyParList); $$ = PASM->m_TyParList; }
                         ;
 
 typarAttrib             : '+'                               { $$ = gpCovariant; }
@@ -495,7 +496,16 @@ typarAttribs            : /* EMPTY */                       { $$ = 0; }
                         | typarAttrib typarAttribs          { $$ = $1 | $2; }
                         ;
 
-typars                  : typarAttribs tyBound dottedName typarsRest {$$ = new TyParList($1, $2, $3, $4);}
+conTyparAttrib          : FLAGS_ '(' int32 ')'              { $$ = (CorGenericParamAttr)$3; }
+                        ;
+
+conTyparAttribs         : /* EMPTY */                       { $$ = 0; }
+                        | conTyparAttrib conTyparAttribs    { $$ = $1 | $2; }
+                        ;
+
+typars                  : LITERAL_ conTyparAttribs type tyBound dottedName typarsRest {$$ = new TyParList($2, $3, $4, $5, $6); }
+                        | LITERAL_ conTyparAttribs type dottedName typarsRest {$$ = new TyParList($2, $3, NULL, $4, $5); }
+                        | typarAttribs tyBound dottedName typarsRest {$$ = new TyParList($1, $2, $3, $4);}
                         | typarAttribs dottedName typarsRest   {$$ = new TyParList($1, NULL, $2, $3);}
                         ;
 
@@ -1254,6 +1264,45 @@ serInit                 : fieldSerInit                       { $$ = $1; }
                                                                $$->insertInt8(ELEMENT_TYPE_SZARRAY); }
                         ;
 
+constTypeArg            : FLOAT32_ '(' float64 ')'           { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_R4);
+                                                               float f = (float)(*$3);
+                                                               $$->appendInt32(*((__int32*)&f)); delete $3; }
+                        | FLOAT64_ '(' float64 ')'           { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_R8);
+                                                               $$->appendInt64((__int64 *)$3); delete $3; }
+                        | FLOAT32_ '(' int32 ')'             { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_R4);
+                                                               $$->appendInt32($3); }
+                        | FLOAT64_ '(' int64 ')'             { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_R8);
+                                                               $$->appendInt64((__int64 *)$3); delete $3; }
+                        | INT64_ '(' int64 ')'               { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_I8);
+                                                               $$->appendInt64((__int64 *)$3); delete $3; }
+                        | INT32_ '(' int32 ')'               { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_I4);
+                                                               $$->appendInt32($3); }
+                        | INT16_ '(' int32 ')'               { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_I2);
+                                                               $$->appendInt16($3); }
+                        | INT8_ '(' int32 ')'                { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_I1);
+                                                               $$->appendInt8($3); }
+                        | UNSIGNED_ INT64_ '(' int64 ')'     { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U8);
+                                                               $$->appendInt64((__int64 *)$4); delete $4; }
+                        | UNSIGNED_ INT32_ '(' int32 ')'     { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U4);
+                                                               $$->appendInt32($4); }
+                        | UNSIGNED_ INT16_ '(' int32 ')'     { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U2);
+                                                               $$->appendInt16($4); }
+                        | UNSIGNED_ INT8_ '(' int32 ')'      { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U1);
+                                                               $$->appendInt8($4); }
+                        | UINT64_ '(' int64 ')'              { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U8);
+                                                               $$->appendInt64((__int64 *)$3); delete $3; }
+                        | UINT32_ '(' int32 ')'              { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U4);
+                                                               $$->appendInt32($3); }
+                        | UINT16_ '(' int32 ')'              { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U2);
+                                                               $$->appendInt16($3); }
+                        | UINT8_ '(' int32 ')'               { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U1);
+                                                               $$->appendInt8($3); }
+                        | CHAR_ '(' int32 ')'                { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_CHAR);
+                                                               $$->appendInt16($3); }
+                        | BOOL_ '(' truefalse ')'            { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_BOOLEAN);
+                                                               $$->appendInt8($3);}
+                        ;
+
 
 f32seq                  : /* EMPTY */                        { $$ = new BinStr(); }
                         | f32seq float64                     { $$ = $1;
@@ -1677,6 +1726,7 @@ type                    : CLASS_ className                    { if($2 == PASM->m
                         | OBJECT_                             { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_OBJECT); }
                         | VALUE_ CLASS_ className             { $$ = parser->MakeTypeClass(ELEMENT_TYPE_VALUETYPE, $3); }
                         | VALUETYPE_ className                { $$ = parser->MakeTypeClass(ELEMENT_TYPE_VALUETYPE, $2); }
+                        | constTypeArg                        { $$ = $1; $$->insertInt8(ELEMENT_TYPE_CTARG); }
                         | type '[' ']'                        { $$ = $1; $$->insertInt8(ELEMENT_TYPE_SZARRAY); }
                         | type '[' bounds1 ']'                { $$ = parser->MakeTypeArray(ELEMENT_TYPE_ARRAY, $1, $3); }
                         | type '&'                            { $$ = $1; $$->insertInt8(ELEMENT_TYPE_BYREF); }

src/coreclr/ilasm/assem.cpp

@@ -684,7 +684,7 @@ BOOL Assembler::EmitMethod(Method *pMethod)
         mdGenericParam tkGP = mdTokenNil;
         for(i = 0; i < pMethod->m_NumTyPars; i++)
         {
-            if (FAILED(m_pEmitter->DefineGenericParam(MethodToken, i, pMethod->m_TyPars[i].Attrs(), pMethod->m_TyPars[i].Name(), 0, &tkNil, &tkGP)))
+            if (FAILED(m_pEmitter->DefineGenericParam(MethodToken, i, pMethod->m_TyPars[i].Attrs(), pMethod->m_TyPars[i].Name(), pMethod->m_TyPars[i].Type(), &tkNil, &tkGP)))
             {
                 report->error("Unable to define generic param: %s'\n", pMethod->m_TyPars[i].Name());
             }
@@ -1118,7 +1118,7 @@ BOOL Assembler::EmitClass(Class *pClass)
         mdGenericParam tkGP = mdTokenNil;
         for(i = 0; i < pClass->m_NumTyPars; i++)
         {
-            if (FAILED(m_pEmitter->DefineGenericParam(pClass->m_cl, i, pClass->m_TyPars[i].Attrs(), pClass->m_TyPars[i].Name(), 0, &tkNil, &tkGP)))
+            if (FAILED(m_pEmitter->DefineGenericParam(pClass->m_cl, i, pClass->m_TyPars[i].Attrs(), pClass->m_TyPars[i].Name(), pClass->m_TyPars[i].Type(), &tkNil, &tkGP)))
             {
                 report->error("Unable to define generic param: %s'\n", pClass->m_TyPars[i].Name());
             }

src/coreclr/ilasm/assembler.h

@@ -869,7 +869,7 @@ class Assembler {
     void SetStdMapping(BOOL val = TRUE) { m_fStdMapping = val; };
 
     //--------------------------------------------------------------------------------
-    BOOL isShort(unsigned instr) { return ((OpcodeInfo[instr].Type & 16) != 0); };
+    BOOL isShort(unsigned instr) { return ((OpcodeInfo[instr].Type & opcode_format_t::ShortInline) != 0); };
     unsigned ShortOf(unsigned opcode);
     void SetErrorReporter(ErrorReporter* aReport) { report = aReport; if(m_pManifest) m_pManifest->SetErrorReporter(aReport); }
 

src/coreclr/ilasm/grammar_after.cpp

@@ -47,7 +47,7 @@ static Keywords keywords[] = {
 #define InlineR                 INSTR_R
 #define ShortInlineR            INSTR_R
 #define InlineBrTarget          INSTR_BRTARGET
-#define ShortInlineBrTarget             INSTR_BRTARGET
+#define ShortInlineBrTarget     INSTR_BRTARGET
 #define InlineMethod            INSTR_METHOD
 #define InlineField             INSTR_FIELD
 #define InlineType              INSTR_TYPE
@@ -1329,7 +1329,6 @@ static void corEmitInt(BinStr* buff, unsigned data)
     buff->remove(5 - cnt);
 }
 
-
 /**************************************************************************/
 /* move 'ptr past the exactly one type description */
 
@@ -1360,11 +1359,13 @@ unsigned __int8* skipType(unsigned __int8* ptr, BOOL fFixupType)
                 /* do nothing */
                 break;
 
-        case ELEMENT_TYPE_VALUETYPE   :
+        case ELEMENT_TYPE_VALUETYPE    :
         case ELEMENT_TYPE_CLASS        :
                 ptr += CorSigUncompressToken(ptr, &tk);
                 break;
-
+        case ELEMENT_TYPE_CTARG        :
+                ptr += CorSigUncompressConstTypeArgData((PCCOR_SIGNATURE&) ptr); // const type argument
+                break;
         case ELEMENT_TYPE_CMOD_REQD    :
         case ELEMENT_TYPE_CMOD_OPT     :
                 ptr += CorSigUncompressToken(ptr, &tk);
@@ -1530,7 +1531,6 @@ unsigned __int8* skipType(unsigned __int8* ptr, BOOL fFixupType)
                    }
                }
                break;
-
         default:
         case ELEMENT_TYPE_END                   :
                 _ASSERTE(!"Unknown Type");
@@ -1557,6 +1557,20 @@ void FixupTyPars(BinStr* pbstype)
     FixupTyPars((PCOR_SIGNATURE)(pbstype->ptr()),(ULONG)(pbstype->length()));
 }
 /**************************************************************************/
+void ResolveTyParList(TyParList* list)
+{
+    TyParList* cur = list;
+    while (cur != NULL)
+    {
+        if (cur->unresolvedType != NULL && cur->type == 0)
+        {
+            FixupTyPars(cur->unresolvedType);
+            cur->type = PASM->ResolveTypeSpec(cur->unresolvedType);
+        }
+        cur = cur->Next();
+    }
+}
+/**************************************************************************/
 static unsigned corCountArgs(BinStr* args)
 {
     unsigned __int8* ptr = args->ptr();

src/coreclr/ilasm/grammar_before.cpp

@@ -51,6 +51,11 @@ static char* newString(_In_ __nullterminated const char* str1);
 static void corEmitInt(BinStr* buff, unsigned data);
 static void AppendStringWithLength(BinStr* pbs, _In_ __nullterminated char* sz);
 static void AppendFieldToCustomBlob(BinStr* pBlob, _In_ BinStr* pField);
+static unsigned corCountArgs(BinStr* args);
+void yyerror(_In_ __nullterminated const char*);
+Instr* SetupInstr(unsigned short);
+int yylex();
+void ResolveTyParList(TyParList* list);
 bool bParsingByteArray = FALSE;
 int iOpcodeLen = 0;
 int iCallConv = 0;