Multiple fixes for emitting local declarations for incoming args

src/coreclr/jit/codegen.h

@@ -13,9 +13,7 @@
 #include "compiler.h" // temporary??
 #include "regset.h"
 #include "jitgcinfo.h"
-
-#include "wasmtypes.h"
-#include "vartype.h"
+#include "wasmtypesdef.h"
 
 class CodeGen final : public CodeGenInterface
 {
@@ -594,7 +592,6 @@ class CodeGen final : public CodeGenInterface
     void genFnProlog();
 #if defined(TARGET_WASM)
     void genWasmArgsAsLocals();
-    instWasmValueType genWasmTypeFromVarType(var_types type);
 #endif
     void genFnEpilog(BasicBlock* block);
 

src/coreclr/jit/codegencommon.cpp

@@ -32,11 +32,6 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 
 #include "jitstd/algorithm.h"
 
-#if defined(TARGET_WASM)
-#include "vartypedef.h"
-#include "wasmtypes.h"
-#endif
-
 /*****************************************************************************/
 
 void CodeGenInterface::setFramePointerRequiredEH(bool value)
@@ -5657,34 +5652,14 @@ void CodeGen::genFnProlog()
 #else  // defined(TARGET_WASM)
     // TODO-WASM: proper local count, local declarations, and shadow stack maintenance
     GetEmitter()->emitIns_I(INS_local_cnt, EA_8BYTE, compiler->info.compArgsCount);
+    genWasmArgsAsLocals();
     GetEmitter()->emitMarkPrologEnd();
 #endif // !defined(TARGET_WASM)
 
     GetEmitter()->emitEndProlog();
 }
 
 #if defined(TARGET_WASM)
-//------------------------------------------------------------------------
-// genWasmTypeFromVarType: map var_type to wasm type
-// 
-instWasmValueType CodeGen::genWasmTypeFromVarType(var_types type)
-{
-    switch (type)
-    {
-        case TYP_INT:
-        case TYP_REF:
-        case TYP_BYREF:
-            return instWasmValueType ;
-        case TYP_LONG:
-            return instWasmValueType::I64;
-        case TYP_FLOAT:
-            return instWasmValueType::F32;
-        case TYP_DOUBLE:
-            return instWasmValueType::F64;
-        default:
-            unreached();
-    }
-}
 
 //------------------------------------------------------------------------
 // genWasmArgsAsLocals: generate wasm locals for all incoming arguments
@@ -5695,8 +5670,8 @@ void CodeGen::genWasmArgsAsLocals()
     {
         LclVarDsc* varDsc = compiler->lvaGetDesc(i);
         assert(varDsc->lvIsParam);
-        instWasmValueType type = genWasmTypeFromVarType(varDsc->TypeGet());
-        GetEmitter()->emitIns_I_Ty(INS_local_decl, emitTypeSize(varDsc->TypeGet()), type);
+        emitter::instWasmValueType type = GetEmitter()->genWasmTypeFromVarType(varDsc->TypeGet());
+        GetEmitter()->emitIns_I_Ty(INS_local_decl, 1, type);
     }
 }
 #endif

src/coreclr/jit/emit.h

@@ -640,6 +640,10 @@ class emitter
         CORINFO_SIG_INFO* idCallSig;     // Used to report native call site signatures to the EE
     };
 
+#if defined(TARGET_WASM)
+#include "wasmtypesdef.h"
+#endif
+
 #ifdef TARGET_ARM
     unsigned insEncodeSetFlags(insFlags sf);
 
@@ -892,6 +896,9 @@ class emitter
         unsigned _idLclFPBase : 1; // access a local on stack - SP based offset
         insOpts  _idInsOpt    : 3; // options for Load/Store instructions
 #endif
+#ifdef TARGET_WASM
+        unsigned _idLclDecl : 1; // is this a local declaration?
+#endif
 
         ////////////////////////////////////////////////////////////////////////
         // Space taken up to here:
@@ -919,7 +926,7 @@ class emitter
 #elif defined(TARGET_AMD64)
 #define ID_EXTRA_BITFIELD_BITS (20)
 #elif defined(TARGET_WASM)
-#define ID_EXTRA_BITFIELD_BITS (-4)
+#define ID_EXTRA_BITFIELD_BITS (-3)
 #else
 #error Unsupported or unset target architecture
 #endif
@@ -1296,6 +1303,18 @@ class emitter
             assert(reg == _idReg1);
         }
 
+#ifdef TARGET_WASM
+        bool idIsLclVarDecl() const 
+        {
+            return (_idLclDecl != 0);
+        }
+
+        void idSetIsLclVarDecl(bool isDecl) 
+        {
+            _idLclDecl = isDecl ? 1 : 0;
+        }
+#endif
+
 #ifdef TARGET_ARM64
         GCtype idGCrefReg2() const
         {
@@ -2335,9 +2354,7 @@ class emitter
     };
 #endif
 
-#ifdef TARGET_WASM
-#include "wasmtypes.h"
-
+#if defined(TARGET_WASM)
     struct instrDescLclVarDecl : instrDesc
     {
         instrDescLclVarDecl() = delete;
@@ -3316,7 +3333,7 @@ class emitter
     instrDesc* emitNewInstrCnsDsp(emitAttr attr, target_ssize_t cns, int dsp);
 
 #ifdef TARGET_WASM
-    instrDesc* emitNewInstrLclVarDecl(emitAttr attr, cnsval_ssize_t localCount, instWasmValueType type);
+
 #endif
 
 #ifdef TARGET_ARM
@@ -4135,16 +4152,10 @@ inline emitter::instrDesc* emitter::emitNewInstrSC(emitAttr attr, cnsval_ssize_t
 }
 
 #ifdef TARGET_WASM
-#include "wasmtypes.h"
+#include "wasmtypesdef.h"
+
 
-inline emitter::instrDesc* emitter::emitNewInstrLclVarDecl(emitAttr attr, cnsval_ssize_t localCount, instWasmValueType type)
-{
-    instrDescLclVarDecl* id = static_cast<instrDescLclVarDecl*>(emitAllocAnyInstr(sizeof(instrDescLclVarDecl), attr));
-    id->idLclCnt(localCount);
-    id->idLclType(type);
 
-    return id;
-}
 #endif
 
 #ifdef TARGET_ARM

src/coreclr/jit/emitwasm.cpp

@@ -85,10 +85,20 @@ bool emitter::emitInsIsStore(instruction ins)
     return false;
 }
 
-//------------------------------------------------------------------------
-// emitIns_I: Emit an instruction with an immediate operand and an encoded valye type
+emitter::instrDesc* emitter::emitNewInstrLclVarDecl(emitAttr attr, cnsval_ssize_t localCount, instWasmValueType type)
+{
+    instrDescLclVarDecl* id = static_cast<instrDescLclVarDecl*>(emitAllocAnyInstr(sizeof(instrDescLclVarDecl), attr));
+    id->idSetIsLclVarDecl(true);
+    id->idLclCnt(localCount);
+    id->idLclType(type);
+
+    return id;
+}
+
+//-----------------------------------------------------------------------------------
+// emitIns_I: Emit an instruction with an immediate operand and an encoded value type
 //
-void emitter::emitIns_I_Ty(instruction ins, cnsval_ssize_t imm, instWasmValueType valType)
+void emitter::emitIns_I_Ty(instruction ins, cnsval_ssize_t imm, emitter::instWasmValueType valType)
 {
     instrDesc* id  = this->emitNewInstrLclVarDecl(EA_8BYTE, imm, valType);
     insFormat  fmt = this->emitInsFormat(ins);
@@ -100,6 +110,26 @@ void emitter::emitIns_I_Ty(instruction ins, cnsval_ssize_t imm, instWasmValueTyp
     this->appendToCurIG(id);
 }
 
+emitter::instWasmValueType emitter::emitGetLclVarDeclType(instrDesc* id)
+{
+    if (!id->idIsLclVarDecl())
+    {
+        noway_assert("not a LclVarDecl instrDesc");
+    }
+
+    return static_cast<instrDescLclVarDecl*>(id)->lclType;
+}
+
+cnsval_ssize_t emitter::emitGetLclVarDeclCount(instrDesc* id)
+{
+    if (!id->idIsLclVarDecl())
+    {
+        noway_assert("not a LclVarDecl instrDesc");
+    }
+
+    return static_cast<instrDescLclVarDecl*>(id)->lclCnt;
+}
+
 emitter::insFormat emitter::emitInsFormat(instruction ins)
 {
     static_assert(IF_COUNT < 255);
@@ -136,6 +166,12 @@ size_t emitter::emitSizeOfInsDsc(instrDesc* id) const
         assert(!id->idIsLargeCall());
         return sizeof(instrDescCns);
     }
+
+    if (id->idIsLclVarDecl())
+    {
+        return sizeof(instrDescLclVarDecl);
+    }
+
     return sizeof(instrDesc);
 }
 
@@ -185,6 +221,13 @@ unsigned emitter::instrDesc::idCodeSize() const
             assert(!idIsCnsReloc());
             size = SizeOfULEB128(emitGetInsSC(this));
             break;
+        case IF_LOCAL_DECL:
+        {
+            assert(idIsLclVarDecl());
+            instrDescLclVarDecl* idl = static_cast<instrDescLclVarDecl*>(const_cast<instrDesc*>(this));
+            size = SizeOfULEB128(idl->lclCnt) + sizeof(emitter::instWasmValueType);
+            break;
+        }
         case IF_ULEB128:
             size += idIsCnsReloc() ? PADDED_RELOC_SIZE : SizeOfULEB128(emitGetInsSC(this));
             break;
@@ -341,11 +384,13 @@ size_t emitter::emitOutputInstr(insGroup* ig, instrDesc* id, BYTE** dp)
         }
         case IF_LOCAL_DECL:
         {
-            cnsval_ssize_t constant = emitGetInsSC(id);
-            dst += emitOutputULEB128(dst, (uint64_t)constant);
+            assert(id->idIsLclVarDecl());
+            cnsval_ssize_t count = emitGetLclVarDeclCount(id);
+            instWasmValueType valType = emitGetLclVarDeclType(id);
+            dst += emitOutputULEB128(dst, (uint64_t)count);
             // TODO-WASM: currently assuming all locals are numtypes which are single byte encoded.
             // vec types are also single byte encoded. If we end up using reftypes, we'll need to handle the more complex encoding.
-            dst += emitOutputByte(dst, static_cast<uint8_t>(instWasmValueType::I32));
+            dst += emitOutputByte(dst, static_cast<uint8_t>(valType));
             break;
         }
         default:
@@ -459,6 +504,14 @@ void emitter::emitDispIns(
         }
         break;
 
+        case IF_LOCAL_DECL:
+        {
+            cnsval_ssize_t imm = emitGetLclVarDeclCount(id);
+            instWasmValueType valType = emitGetLclVarDeclType(id);
+            printf(" %llu %s", (uint64_t)imm, instWasmValueTypeToStr(valType));
+        }
+        break;
+
         case IF_SLEB128:
         {
             cnsval_ssize_t imm = emitGetInsSC(id);

src/coreclr/jit/emitwasm.h

@@ -5,7 +5,7 @@
 /*             Debug-only routines to display instructions              */
 /************************************************************************/
 
-#include "wasmtypes.h"
+#include "wasmtypesdef.h"
 
 #if defined(DEBUG) || defined(LATE_DISASM)
 void getInsSveExecutionCharacteristics(instrDesc* id, insExecutionCharacteristics& result);
@@ -35,6 +35,10 @@ static unsigned SizeOfSLEB128(int64_t value);
 
 static unsigned emitGetAlignHintLog2(const instrDesc* id);
 
+instrDesc* emitNewInstrLclVarDecl(emitAttr attr, cnsval_ssize_t localCount, instWasmValueType type);
+static instWasmValueType emitGetLclVarDeclType(instrDesc* id);
+static cnsval_ssize_t emitGetLclVarDeclCount(instrDesc* id);
+
 /************************************************************************/
 /*  Private members that deal with target-dependent instr. descriptors  */
 /************************************************************************/

src/coreclr/jit/wasmtypesdef.h

@@ -0,0 +1,62 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+/*****************************************************************************/
+#ifndef _WASMTYPESDEF_H_
+#define _WASMTYPESDEF_H_
+/*****************************************************************************/
+
+#include <cstdint>
+#include "vartypesdef.h"
+
+#if defined(TARGET_WASM)
+enum class instWasmValueType : uint8_t
+{
+    F64 = 0x7C,
+    F32 = 0x7D,
+    I64 = 0x7E,
+    I32 = 0x7F,
+};
+
+const char *const wasmValueTypeNames[4] = {
+    "f64",
+    "f32",
+    "i64",
+    "i32",
+};
+
+//------------------------------------------------------------------------
+// wasmValueTypeToStr: map wasm type to string
+const char *const instWasmValueTypeToStr(instWasmValueType type)
+{
+    assert((type >= instWasmValueType::F64) && (type <= instWasmValueType::I32));
+    return wasmValueTypeNames[static_cast<uint8_t>(type) - static_cast<uint8_t>(instWasmValueType::F64)];
+}
+
+//------------------------------------------------------------------------
+// genWasmTypeFromVarType: map var_type to wasm type
+// 
+instWasmValueType genWasmTypeFromVarType(var_types type)
+{
+    switch (type)
+    {
+        case TYP_INT:
+        case TYP_REF:
+        case TYP_BYREF:
+            return instWasmValueType::I32;
+        case TYP_LONG:
+            return instWasmValueType::I64;
+        case TYP_FLOAT:
+            return instWasmValueType::F32;
+        case TYP_DOUBLE:
+            return instWasmValueType::F64;
+        default:
+            unreached();
+    }
+}
+#endif
+
+/*****************************************************************************/
+#endif // _WASMTYPESDEF_H_
+/*****************************************************************************/
+