Add WasmScriptFunction for wasm instead of AsmJsScriptFunction.

Cleanup how we get the WasmMemory and Asm.Js ArrayBuffer

lib/Backend/Lower.cpp

@@ -7991,7 +7991,7 @@ Lowerer::LowerCheckWasmSignature(IR::Instr * instr)
 
     IR::Instr *instrPrev = instr->m_prev;
 
-    IR::IndirOpnd * actualSig = IR::IndirOpnd::New(instr->UnlinkSrc1()->AsRegOpnd(), Js::AsmJsScriptFunction::GetOffsetOfSignature(), TyMachReg, m_func);
+    IR::IndirOpnd * actualSig = IR::IndirOpnd::New(instr->UnlinkSrc1()->AsRegOpnd(), Js::WasmScriptFunction::GetOffsetOfSignature(), TyMachReg, m_func);
 
     Wasm::WasmSignature * expectedSig = m_func->GetJITFunctionBody()->GetAsmJsInfo()->GetWasmSignature(sigId);
     if (expectedSig->GetShortSig() == Js::Constants::InvalidSignature)

lib/Runtime/Base/CrossSite.cpp

@@ -326,7 +326,7 @@ namespace Js
         TTD_XSITE_LOG(callable->GetScriptContext(), "DefaultOrProfileThunk", callable);
 
 #ifdef ENABLE_WASM
-        if (AsmJsScriptFunction::IsWasmScriptFunction(function))
+        if (WasmScriptFunction::Is(function))
         {
             AsmJsFunctionInfo* asmInfo = funcInfo->GetFunctionBody()->GetAsmJsFunctionInfo();
             Assert(asmInfo);

lib/Runtime/Base/ScriptContext.cpp

@@ -3920,7 +3920,7 @@ namespace Js
 #if defined(ENABLE_SCRIPT_DEBUGGING) || defined(ENABLE_SCRIPT_PROFILING)
         RUNTIME_ARGUMENTS(args, callInfo);
 
-        Assert(!AsmJsScriptFunction::IsWasmScriptFunction(callable));
+        Assert(!WasmScriptFunction::Is(callable));
         JavascriptFunction* function = JavascriptFunction::FromVar(callable);
         ScriptContext* scriptContext = function->GetScriptContext();
 

lib/Runtime/Language/AsmJsModule.cpp

@@ -2449,27 +2449,27 @@ namespace Js
 
     void AsmJsModuleInfo::EnsureHeapAttached(ScriptFunction * func)
     {
-        FrameDisplay* frame = func->GetEnvironment();
-        ArrayBuffer* moduleArrayBuffer = nullptr;
 #ifdef ENABLE_WASM
-        if (func->GetFunctionBody()->IsWasmFunction())
+        if (WasmScriptFunction::Is(func))
         {
-            WebAssemblyMemory * wasmMem = *(WebAssemblyMemory**)((Var*)frame->GetItem(0) + AsmJsModuleMemory::MemoryTableBeginOffset);
-            if (wasmMem != nullptr)
+            WasmScriptFunction* wasmFunc = WasmScriptFunction::FromVar(func);
+            WebAssemblyMemory * wasmMem = wasmFunc->GetWebAssemblyMemory();
+            if (wasmMem && wasmMem->GetBuffer() && wasmMem->GetBuffer()->IsDetached())
             {
-                moduleArrayBuffer = wasmMem->GetBuffer();
+                Throw::OutOfMemory();
             }
         }
         else
 #endif
         {
-            moduleArrayBuffer = *(ArrayBuffer**)((Var*)frame->GetItem(0) + AsmJsModuleMemory::MemoryTableBeginOffset);
+            AsmJsScriptFunction* asmFunc = AsmJsScriptFunction::FromVar(func);
+            ArrayBuffer* moduleArrayBuffer = asmFunc->GetAsmJsArrayBuffer();
+            if (moduleArrayBuffer && moduleArrayBuffer->IsDetached())
+            {
+                Throw::OutOfMemory();
+            }
         }
 
-        if (moduleArrayBuffer && moduleArrayBuffer->IsDetached())
-        {
-            Throw::OutOfMemory();
-        }
     }
 
     void * AsmJsModuleInfo::ConvertFrameForJavascript(void * asmMemory, ScriptFunction* func)

lib/Runtime/Language/InterpreterStackFrame.cpp

@@ -3022,20 +3022,20 @@ namespace Js
         }
 
         // Load module environment
-        FrameDisplay* frame = this->function->GetEnvironment();
-        m_localSlots[AsmJsFunctionMemory::ModuleEnvRegister] = frame->GetItem(0);
+        AsmJsScriptFunction* asmJsFunc = AsmJsScriptFunction::FromVar(this->function);
+        m_localSlots[AsmJsFunctionMemory::ModuleEnvRegister] = asmJsFunc->GetModuleMemory();
 #ifdef ENABLE_WASM
-        if (func->GetFunctionBody()->IsWasmFunction())
+        if (WasmScriptFunction::Is(func))
         {
-            WebAssemblyMemory * wasmMem = *(WebAssemblyMemory**)((Var*)frame->GetItem(0) + AsmJsModuleMemory::MemoryTableBeginOffset);
+            WasmScriptFunction* wasmFunc = WasmScriptFunction::FromVar(func);
+            m_wasmMemory = wasmFunc->GetWebAssemblyMemory();
             m_signatures = func->GetFunctionBody()->GetAsmJsFunctionInfo()->GetWebAssemblyModule()->GetSignatures();
-            m_wasmMemory = wasmMem;
             m_localSlots[AsmJsFunctionMemory::ArrayBufferRegister] = nullptr;
         }
         else
 #endif
         {
-            m_localSlots[AsmJsFunctionMemory::ArrayBufferRegister] = (Var*)frame->GetItem(0) + AsmJsModuleMemory::MemoryTableBeginOffset;
+            m_localSlots[AsmJsFunctionMemory::ArrayBufferRegister] = asmJsFunc->GetAsmJsArrayBufferAddr();
         }
 
         m_localSlots[AsmJsFunctionMemory::ArraySizeRegister] = 0; // do not cache ArraySize in the interpreter

lib/Runtime/Language/i386/AsmJsJitTemplate.cpp

@@ -551,14 +551,13 @@ namespace Js
         AsmJsSIMDValue* simdArg;
 
         // setup stack memory
-        FrameDisplay* frame = func->GetEnvironment();
-        Var moduleEnv = frame->GetItem(0);
-        Var* arrayBufferVar = (Var*)frame->GetItem(0) + AsmJsModuleMemory::MemoryTableBeginOffset;
+        AsmJsScriptFunction* asmJsFunc = AsmJsScriptFunction::FromVar(func);
+        Var moduleEnv = asmJsFunc->GetModuleMemory();
+        JavascriptArrayBuffer* arrayBuffer = asmJsFunc->GetAsmJsArrayBuffer();
         int arraySize = 0;
         BYTE* arrayPtr = nullptr;
-        if (*arrayBufferVar && JavascriptArrayBuffer::Is(*arrayBufferVar))
+        if (JavascriptArrayBuffer::Is(arrayBuffer))
         {
-            JavascriptArrayBuffer* arrayBuffer = *(JavascriptArrayBuffer**)arrayBufferVar;
             arrayPtr = arrayBuffer->GetBuffer();
             arraySize = arrayBuffer->GetByteLength();
         }

lib/Runtime/Library/JavascriptFunction.cpp

@@ -2301,15 +2301,15 @@ LABEL1:
         {
             return false;
         }
-        Js::FunctionBody* funcBody = func->GetFunctionBody();
-        bool isWAsmJs = funcBody->GetIsAsmJsFunction();
-        bool isWasmOnly = funcBody->IsWasmFunction();
+
+        bool isWAsmJs = AsmJsScriptFunction::Is(func);
+        bool isWasmOnly = WasmScriptFunction::Is(func);
         uintptr_t faultingAddr = helper.GetFaultingAddress();
         if (isWAsmJs)
         {
+            AsmJsScriptFunction* asmFunc = AsmJsScriptFunction::FromVar(func);
             // some extra checks for asm.js because we have slightly more information that we can validate
-            uintptr_t moduleMemory = (uintptr_t)((AsmJsScriptFunction*)func)->GetModuleMemory();
-            if (!moduleMemory)
+            if (!asmFunc->GetModuleMemory())
             {
                 return false;
             }
@@ -2319,14 +2319,14 @@ LABEL1:
 #ifdef ENABLE_WASM
             if (isWasmOnly)
             {
-                WebAssemblyMemory* mem = *(WebAssemblyMemory**)(moduleMemory + WebAssemblyModule::GetMemoryOffset());
+                WebAssemblyMemory* mem = WasmScriptFunction::FromVar(func)->GetWebAssemblyMemory();
                 arrayBuffer = mem->GetBuffer();
                 reservationSize = MAX_WASM__ARRAYBUFFER_LENGTH;
             }
             else
 #endif
             {
-                arrayBuffer = *(ArrayBuffer**)(moduleMemory + AsmJsModuleMemory::MemoryTableBeginOffset);
+                arrayBuffer = asmFunc->GetAsmJsArrayBuffer();
                 reservationSize = MAX_ASMJS_ARRAYBUFFER_LENGTH;
             }
 

lib/Runtime/Library/JavascriptLibrary.cpp

@@ -6564,6 +6564,12 @@ namespace Js
         return RecyclerNewEnumClass(this->GetRecycler(), EnumFunctionClass, AsmJsScriptFunction, proxy, deferredPrototypeType);
     }
 
+    WasmScriptFunction * JavascriptLibrary::CreateWasmScriptFunction(FunctionProxy* proxy)
+    {
+        ScriptFunctionType* deferredPrototypeType = proxy->EnsureDeferredPrototypeType();
+        return RecyclerNewEnumClass(this->GetRecycler(), EnumFunctionClass, WasmScriptFunction, proxy, deferredPrototypeType);
+    }
+
     ScriptFunctionWithInlineCache* JavascriptLibrary::CreateScriptFunctionWithInlineCache(FunctionProxy * proxy)
     {
         ScriptFunctionType* deferredPrototypeType = proxy->EnsureDeferredPrototypeType();

lib/Runtime/Library/JavascriptLibrary.h

@@ -1029,6 +1029,7 @@ namespace Js
         DynamicType * CreateFunctionWithLengthAndPrototypeType(DynamicObject * prototype, FunctionInfo * functionInfo);
         ScriptFunction * CreateScriptFunction(FunctionProxy* proxy);
         AsmJsScriptFunction * CreateAsmJsScriptFunction(FunctionProxy* proxy);
+        WasmScriptFunction * CreateWasmScriptFunction(FunctionProxy* proxy);
         ScriptFunctionWithInlineCache * CreateScriptFunctionWithInlineCache(FunctionProxy* proxy);
         GeneratorVirtualScriptFunction * CreateGeneratorVirtualScriptFunction(FunctionProxy* proxy);
         DynamicType * CreateGeneratorType(RecyclableObject* prototype);

lib/Runtime/Library/ScriptFunction.cpp

@@ -653,16 +653,7 @@ namespace Js
 
     bool AsmJsScriptFunction::Is(Var func)
     {
-        return ScriptFunction::Is(func) &&
-            ScriptFunction::FromVar(func)->HasFunctionBody() &&
-            ScriptFunction::FromVar(func)->GetFunctionBody()->GetIsAsmJsFunction();
-    }
-
-    bool AsmJsScriptFunction::IsWasmScriptFunction(Var func)
-    {
-        return ScriptFunction::Is(func) &&
-            ScriptFunction::FromVar(func)->HasFunctionBody() &&
-            ScriptFunction::FromVar(func)->GetFunctionBody()->IsWasmFunction();
+        return ScriptFunction::Is(func) && ScriptFunction::FromVar(func)->IsAsmJsFunction();
     }
 
     AsmJsScriptFunction* AsmJsScriptFunction::FromVar(Var func)
@@ -692,6 +683,40 @@ namespace Js
         return asmJsFunc;
     }
 
+    Js::JavascriptArrayBuffer** AsmJsScriptFunction::GetAsmJsArrayBufferAddr() const
+    {
+        return (JavascriptArrayBuffer**)(this->GetModuleMemory() + AsmJsModuleMemory::MemoryTableBeginOffset);
+    }
+
+    JavascriptArrayBuffer* AsmJsScriptFunction::GetAsmJsArrayBuffer() const
+    {
+        return *GetAsmJsArrayBufferAddr();
+    }
+
+    bool WasmScriptFunction::Is(Var func)
+    {
+        return ScriptFunction::Is(func) && ScriptFunction::FromVar(func)->IsWasmFunction();
+    }
+
+    WasmScriptFunction* WasmScriptFunction::FromVar(Var func)
+    {
+        Assert(WasmScriptFunction::Is(func));
+        return reinterpret_cast<WasmScriptFunction *>(func);
+    }
+
+    WebAssemblyMemory* WasmScriptFunction::GetWebAssemblyMemory() const
+    {
+        return *(WebAssemblyMemory**)(this->GetModuleMemory() + AsmJsModuleMemory::MemoryTableBeginOffset);
+    }
+
+    WasmScriptFunction::WasmScriptFunction(DynamicType * type) :
+        AsmJsScriptFunction(type), m_signature(nullptr)
+    {}
+
+    WasmScriptFunction::WasmScriptFunction(FunctionProxy * proxy, ScriptFunctionType* deferredPrototypeType) :
+        AsmJsScriptFunction(proxy, deferredPrototypeType), m_signature(nullptr)
+    {}
+
     ScriptFunctionWithInlineCache::ScriptFunctionWithInlineCache(FunctionProxy * proxy, ScriptFunctionType* deferredPrototypeType) :
         ScriptFunction(proxy, deferredPrototypeType), hasOwnInlineCaches(false)
     {}

lib/Runtime/Library/ScriptFunction.h

@@ -97,6 +97,8 @@ namespace Js
         virtual JavascriptString* GetDisplayNameImpl() const;
         JavascriptString* GetComputedName() const;
         virtual bool IsAnonymousFunction() const override;
+        virtual bool IsAsmJsFunction() const { return false; }
+        virtual bool IsWasmFunction() const { return false; }
 
         virtual JavascriptFunction* GetRealFunctionObject() { return this; }
 
@@ -124,19 +126,17 @@ namespace Js
         AsmJsScriptFunction(FunctionProxy * proxy, ScriptFunctionType* deferredPrototypeType);
 
         static bool Is(Var func);
-        static bool IsWasmScriptFunction(Var func);
         static AsmJsScriptFunction* FromVar(Var func);
         static AsmJsScriptFunction * OP_NewAsmJsFunc(FrameDisplay *environment, FunctionInfoPtrPtr infoRef);
 
+        virtual bool IsAsmJsFunction() const { return true; }
+
         void SetModuleMemory(Field(Var)* mem) { m_moduleMemory = mem; }
         Field(Var)* GetModuleMemory() const { return m_moduleMemory; }
-
-#ifdef ENABLE_WASM
-        void SetSignature(Wasm::WasmSignature * sig) { m_signature = sig; }
-        Wasm::WasmSignature * GetSignature() const { return m_signature; }
-        static uint32 GetOffsetOfSignature() { return offsetof(AsmJsScriptFunction, m_signature); }
-#endif
         static uint32 GetOffsetOfModuleMemory() { return offsetof(AsmJsScriptFunction, m_moduleMemory); }
+
+        JavascriptArrayBuffer** GetAsmJsArrayBufferAddr() const;
+        JavascriptArrayBuffer* GetAsmJsArrayBuffer() const;
     protected:
         AsmJsScriptFunction(DynamicType * type);
         DEFINE_VTABLE_CTOR(AsmJsScriptFunction, ScriptFunction);
@@ -144,10 +144,32 @@ namespace Js
 
     private:
         Field(Field(Var)*) m_moduleMemory;
+    };
+
 #ifdef ENABLE_WASM
+    class WasmScriptFunction : public AsmJsScriptFunction
+    {
+    public:
+        WasmScriptFunction(FunctionProxy * proxy, ScriptFunctionType* deferredPrototypeType);
+
+        static bool Is(Var func);
+        static WasmScriptFunction* FromVar(Var func);
+
+        void SetSignature(Wasm::WasmSignature * sig) { m_signature = sig; }
+        Wasm::WasmSignature * GetSignature() const { return m_signature; }
+        static uint32 GetOffsetOfSignature() { return offsetof(WasmScriptFunction, m_signature); }
+
+        WebAssemblyMemory* GetWebAssemblyMemory() const;
+
+        virtual bool IsWasmFunction() const { return true; }
+    protected:
+        WasmScriptFunction(DynamicType * type);
+        DEFINE_VTABLE_CTOR(WasmScriptFunction, AsmJsScriptFunction);
+        DEFINE_MARSHAL_OBJECT_TO_SCRIPT_CONTEXT(WasmScriptFunction);
+    private:
         Field(Wasm::WasmSignature *) m_signature;
-#endif
     };
+#endif
 
     class ScriptFunctionWithInlineCache : public ScriptFunction
     {

lib/Runtime/Library/WasmLibrary.cpp

@@ -14,7 +14,7 @@ namespace Js
 
     Var WasmLibrary::WasmLazyTrapCallback(RecyclableObject *callee, CallInfo, ...)
     {
-        AsmJsScriptFunction* asmFunction = static_cast<AsmJsScriptFunction*>(callee);
+        WasmScriptFunction* asmFunction = static_cast<WasmScriptFunction*>(callee);
         Assert(asmFunction);
         ScriptContext * scriptContext = asmFunction->GetScriptContext();
         Assert(scriptContext);
@@ -24,7 +24,7 @@ namespace Js
 
     void WasmLibrary::SetWasmEntryPointToInterpreter(Js::ScriptFunction* func, bool deferParse)
     {
-        Assert(AsmJsScriptFunction::Is(func));
+        Assert(WasmScriptFunction::Is(func));
         FunctionEntryPointInfo* entrypointInfo = (FunctionEntryPointInfo*)func->GetEntryPointInfo();
         entrypointInfo->SetIsAsmJSFunction(true);
 

lib/Runtime/Library/WebAssemblyEnvironment.cpp

@@ -41,7 +41,7 @@ WebAssemblyEnvironment::WebAssemblyEnvironment(WebAssemblyModule* module):
 }
 
 template<typename T>
-void Js::WebAssemblyEnvironment::CheckPtrIsValid(intptr_t ptr) const
+void WebAssemblyEnvironment::CheckPtrIsValid(intptr_t ptr) const
 {
     if (ptr < (intptr_t)PointerValue(start) || (intptr_t)(ptr + sizeof(T)) > (intptr_t)PointerValue(end))
     {
@@ -50,7 +50,7 @@ void Js::WebAssemblyEnvironment::CheckPtrIsValid(intptr_t ptr) const
 }
 
 template<typename T>
-T* Js::WebAssemblyEnvironment::GetVarElement(Field(Var)* ptr, uint32 index, uint32 maxCount) const
+T* WebAssemblyEnvironment::GetVarElement(Field(Var)* ptr, uint32 index, uint32 maxCount) const
 {
     if (index >= maxCount)
     {
@@ -72,7 +72,7 @@ T* Js::WebAssemblyEnvironment::GetVarElement(Field(Var)* ptr, uint32 index, uint
 }
 
 template<typename T>
-void Js::WebAssemblyEnvironment::SetVarElement(Field(Var)* ptr, T* val, uint32 index, uint32 maxCount)
+void WebAssemblyEnvironment::SetVarElement(Field(Var)* ptr, T* val, uint32 index, uint32 maxCount)
 {
     if (index >= maxCount ||
         !T::Is(val))
@@ -86,25 +86,24 @@ void Js::WebAssemblyEnvironment::SetVarElement(Field(Var)* ptr, T* val, uint32 i
     *dst = val;
 }
 
-AsmJsScriptFunction* WebAssemblyEnvironment::GetWasmFunction(uint32 index) const
+WasmScriptFunction* WebAssemblyEnvironment::GetWasmFunction(uint32 index) const
 {
     if (!(module->GetFunctionIndexType(index) == Wasm::FunctionIndexTypes::Function ||
           module->GetFunctionIndexType(index) == Wasm::FunctionIndexTypes::ImportThunk))
     {
         Js::Throw::InternalError();
     }
-    return GetVarElement<AsmJsScriptFunction>(functions, index, module->GetWasmFunctionCount());
+    return GetVarElement<WasmScriptFunction>(functions, index, module->GetWasmFunctionCount());
 }
 
-void WebAssemblyEnvironment::SetWasmFunction(uint32 index, AsmJsScriptFunction* func)
+void WebAssemblyEnvironment::SetWasmFunction(uint32 index, WasmScriptFunction* func)
 {
     if (!(module->GetFunctionIndexType(index) == Wasm::FunctionIndexTypes::Function ||
-          module->GetFunctionIndexType(index) == Wasm::FunctionIndexTypes::ImportThunk) ||
-        !AsmJsScriptFunction::IsWasmScriptFunction(func))
+          module->GetFunctionIndexType(index) == Wasm::FunctionIndexTypes::ImportThunk))
     {
         Js::Throw::InternalError();
     }
-    SetVarElement<AsmJsScriptFunction>(functions, func, index, module->GetWasmFunctionCount());
+    SetVarElement<WasmScriptFunction>(functions, func, index, module->GetWasmFunctionCount());
 }
 
 void WebAssemblyEnvironment::SetImportedFunction(uint32 index, Var importedFunc)

lib/Runtime/Library/WebAssemblyEnvironment.h

@@ -22,8 +22,8 @@ namespace Js
 
         Var* GetStartPtr() const { return (Var*)PointerValue(start); }
 
-        AsmJsScriptFunction* GetWasmFunction(uint32 index) const;
-        void SetWasmFunction(uint32 index, AsmJsScriptFunction* func);
+        WasmScriptFunction* GetWasmFunction(uint32 index) const;
+        void SetWasmFunction(uint32 index, WasmScriptFunction* func);
         void SetImportedFunction(uint32 index, Var importedFunc);
         WebAssemblyTable* GetTable(uint32 index) const;
         void SetTable(uint32 index, class WebAssemblyTable* table);

lib/Runtime/Library/WebAssemblyInstance.cpp

@@ -131,20 +131,20 @@ WebAssemblyInstance::CreateInstance(WebAssemblyModule * module, Var importObject
     try
     {
         LoadImports(module, scriptContext, importObject, &environment);
-        LoadGlobals(module, scriptContext, &environment);
-        LoadFunctions(module, scriptContext, &environment);
         ValidateTableAndMemory(module, scriptContext, &environment);
+        InitialGlobals(module, scriptContext, &environment);
+        CreateWasmFunctions(module, scriptContext, &environment);
         try
         {
-            LoadDataSegs(module, scriptContext, &environment);
-            LoadIndirectFunctionTable(module, scriptContext, &environment);
+            InitializeDataSegs(module, scriptContext, &environment);
+            InitializeFunctionTable(module, scriptContext, &environment);
         }
         catch (...)
         {
             AssertMsg(UNREACHED, "By spec, we should not have any exceptions possible here");
             throw;
         }
-        newInstance->m_exports = BuildObject(module, scriptContext, &environment);
+        newInstance->m_exports = CreateExportObject(module, scriptContext, &environment);
     }
     catch (Wasm::WasmCompilationException& e)
     {
@@ -154,7 +154,7 @@ WebAssemblyInstance::CreateInstance(WebAssemblyModule * module, Var importObject
     uint32 startFuncIdx = module->GetStartFunction();
     if (startFuncIdx != Js::Constants::UninitializedValue)
     {
-        AsmJsScriptFunction* start = environment.GetWasmFunction(startFuncIdx);
+        WasmScriptFunction* start = environment.GetWasmFunction(startFuncIdx);
         Js::CallInfo info(Js::CallFlags_New, 1);
         Js::Arguments startArg(info, (Var*)&start);
         Js::JavascriptFunction::CallFunction<true>(start, start->GetEntryPoint(), startArg);
@@ -163,7 +163,7 @@ WebAssemblyInstance::CreateInstance(WebAssemblyModule * module, Var importObject
     return newInstance;
 }
 
-void WebAssemblyInstance::LoadFunctions(WebAssemblyModule * wasmModule, ScriptContext* ctx, WebAssemblyEnvironment* env)
+void WebAssemblyInstance::CreateWasmFunctions(WebAssemblyModule * wasmModule, ScriptContext* ctx, WebAssemblyEnvironment* env)
 {
     FrameDisplay * frameDisplay = RecyclerNewPlus(ctx->GetRecycler(), sizeof(void*), FrameDisplay, 1);
     frameDisplay->SetItem(0, env->GetStartPtr());
@@ -176,7 +176,7 @@ void WebAssemblyInstance::LoadFunctions(WebAssemblyModule * wasmModule, ScriptCo
         }
         Wasm::WasmFunctionInfo* wasmFuncInfo = wasmModule->GetWasmFunctionInfo(i);
         FunctionBody* body = wasmFuncInfo->GetBody();
-        AsmJsScriptFunction * funcObj = ctx->GetLibrary()->CreateAsmJsScriptFunction(body);
+        WasmScriptFunction* funcObj = ctx->GetLibrary()->CreateWasmScriptFunction(body);
         funcObj->SetModuleMemory((Field(Var)*)env->GetStartPtr());
         funcObj->SetSignature(body->GetAsmJsFunctionInfo()->GetWasmSignature());
         funcObj->SetEnvironment(frameDisplay);
@@ -210,7 +210,7 @@ void WebAssemblyInstance::LoadFunctions(WebAssemblyModule * wasmModule, ScriptCo
     }
 }
 
-void WebAssemblyInstance::LoadDataSegs(WebAssemblyModule * wasmModule, ScriptContext* ctx, WebAssemblyEnvironment* env)
+void WebAssemblyInstance::InitializeDataSegs(WebAssemblyModule * wasmModule, ScriptContext* ctx, WebAssemblyEnvironment* env)
 {
     WebAssemblyMemory* mem = env->GetMemory(0);
     Assert(mem);
@@ -230,7 +230,7 @@ void WebAssemblyInstance::LoadDataSegs(WebAssemblyModule * wasmModule, ScriptCon
     }
 }
 
-Var WebAssemblyInstance::BuildObject(WebAssemblyModule * wasmModule, ScriptContext* scriptContext, WebAssemblyEnvironment* env)
+Var WebAssemblyInstance::CreateExportObject(WebAssemblyModule * wasmModule, ScriptContext* scriptContext, WebAssemblyEnvironment* env)
 {
     Js::Var exportsNamespace = scriptContext->GetLibrary()->CreateObject(scriptContext->GetLibrary()->GetNull());
     for (uint32 iExport = 0; iExport < wasmModule->GetExportCount(); ++iExport)
@@ -317,10 +317,10 @@ void WebAssemblyInstance::LoadImports(
             Assert(wasmModule->GetFunctionIndexType(counter) == Wasm::FunctionIndexTypes::ImportThunk);
 
             env->SetImportedFunction(counter, prop);
-            if (AsmJsScriptFunction::IsWasmScriptFunction(prop))
+            if (WasmScriptFunction::Is(prop))
             {
                 Assert(env->GetWasmFunction(counter) == nullptr);
-                AsmJsScriptFunction* func = AsmJsScriptFunction::FromVar(prop);
+                WasmScriptFunction* func = WasmScriptFunction::FromVar(prop);
                 if (!wasmModule->GetWasmFunctionInfo(counter)->GetSignature()->IsEquivalent(func->GetSignature()))
                 {
                     char16 temp[2048] = { 0 };
@@ -412,7 +412,7 @@ void WebAssemblyInstance::LoadImports(
     }
 }
 
-void WebAssemblyInstance::LoadGlobals(WebAssemblyModule * wasmModule, ScriptContext* ctx, WebAssemblyEnvironment* env)
+void WebAssemblyInstance::InitialGlobals(WebAssemblyModule * wasmModule, ScriptContext* ctx, WebAssemblyEnvironment* env)
 {
     uint count = wasmModule->GetGlobalCount();
     for (uint i = 0; i < count; i++)
@@ -450,7 +450,7 @@ void WebAssemblyInstance::LoadGlobals(WebAssemblyModule * wasmModule, ScriptCont
     }
 }
 
-void WebAssemblyInstance::LoadIndirectFunctionTable(WebAssemblyModule * wasmModule, ScriptContext* ctx, WebAssemblyEnvironment* env)
+void WebAssemblyInstance::InitializeFunctionTable(WebAssemblyModule * wasmModule, ScriptContext* ctx, WebAssemblyEnvironment* env)
 {
     WebAssemblyTable* table = env->GetTable(0);
     Assert(table != nullptr);

lib/Runtime/Library/WebAssemblyInstance.h

@@ -32,12 +32,12 @@ namespace Js
     private:
         WebAssemblyInstance(WebAssemblyModule * wasmModule, DynamicType * type);
 
-        static void LoadDataSegs(WebAssemblyModule * wasmModule, ScriptContext* ctx, WebAssemblyEnvironment* env);
-        static void LoadFunctions(WebAssemblyModule * wasmModule, ScriptContext* ctx, WebAssemblyEnvironment* env);
-        static Var  BuildObject(WebAssemblyModule * wasmModule, ScriptContext* ctx, WebAssemblyEnvironment* env);
+        static void InitializeDataSegs(WebAssemblyModule * wasmModule, ScriptContext* ctx, WebAssemblyEnvironment* env);
+        static void CreateWasmFunctions(WebAssemblyModule * wasmModule, ScriptContext* ctx, WebAssemblyEnvironment* env);
+        static Var  CreateExportObject(WebAssemblyModule * wasmModule, ScriptContext* ctx, WebAssemblyEnvironment* env);
         static void LoadImports(WebAssemblyModule * wasmModule, ScriptContext* ctx, Var ffi, WebAssemblyEnvironment* env);
-        static void LoadGlobals(WebAssemblyModule * wasmModule, ScriptContext* ctx, WebAssemblyEnvironment* env);
-        static void LoadIndirectFunctionTable(WebAssemblyModule * wasmModule, ScriptContext* ctx, WebAssemblyEnvironment* env);
+        static void InitialGlobals(WebAssemblyModule * wasmModule, ScriptContext* ctx, WebAssemblyEnvironment* env);
+        static void InitializeFunctionTable(WebAssemblyModule * wasmModule, ScriptContext* ctx, WebAssemblyEnvironment* env);
         static void ValidateTableAndMemory(WebAssemblyModule * wasmModule, ScriptContext* ctx, WebAssemblyEnvironment* env);
 
         Field(WebAssemblyModule *) m_module;

lib/Runtime/Library/WebAssemblyModule.cpp

@@ -290,7 +290,7 @@ WebAssemblyModule::ValidateModule(
             if (PHASE_ON(WasmValidatePrejitPhase, body))
             {
                 CONFIG_FLAG(MaxAsmJsInterpreterRunCount) = 0;
-                AsmJsScriptFunction * funcObj = scriptContext->GetLibrary()->CreateAsmJsScriptFunction(body);
+                WasmScriptFunction * funcObj = scriptContext->GetLibrary()->CreateWasmScriptFunction(body);
                 FunctionEntryPointInfo * entrypointInfo = (FunctionEntryPointInfo*)funcObj->GetEntryPointInfo();
                 entrypointInfo->SetIsAsmJSFunction(true);
                 GenerateFunction(scriptContext->GetNativeCodeGenerator(), body, funcObj);

lib/Runtime/Library/WebAssemblyTable.cpp

@@ -194,7 +194,7 @@ WebAssemblyTable::EntrySet(RecyclableObject* function, CallInfo callInfo, ...)
     {
         value = nullptr;
     }
-    else if (!AsmJsScriptFunction::IsWasmScriptFunction(args[2]))
+    else if (!WasmScriptFunction::Is(args[2]))
     {
         JavascriptError::ThrowTypeError(scriptContext, WASMERR_NeedWebAssemblyFunc);
     }
@@ -229,7 +229,7 @@ void
 WebAssemblyTable::DirectSetValue(uint index, Var val)
 {
     Assert(index < m_currentLength);
-    Assert(!val || AsmJsScriptFunction::Is(val));
+    Assert(!val || WasmScriptFunction::Is(val));
     m_values[index] = val;
 }
 
@@ -238,7 +238,7 @@ WebAssemblyTable::DirectGetValue(uint index) const
 {
     Assert(index < m_currentLength);
     Var val = m_values[index];
-    Assert(!val || AsmJsScriptFunction::Is(val));
+    Assert(!val || WasmScriptFunction::Is(val));
     return val;
 }
 

lib/Runtime/Runtime.h

@@ -202,6 +202,7 @@ namespace Js
     class JavascriptGeneratorFunction;
     class JavascriptAsyncFunction;
     class AsmJsScriptFunction;
+    class WasmScriptFunction;
     class JavascriptRegExpConstructor;
     class JavascriptRegExpEnumerator;
     class BoundFunction;