Remove ENABLE_DOM_FAST_PATH

lib/Backend/GlobOpt.cpp

@@ -14605,10 +14605,6 @@ swap_srcs:
     case Js::OpCode::NewConcatStrMulti:
     case Js::OpCode::NewConcatStrMultiBE:
     case Js::OpCode::ExtendArg_A:
-#ifdef ENABLE_DOM_FAST_PATH
-    case Js::OpCode::DOMFastPathGetter:
-    case Js::OpCode::DOMFastPathSetter:
-#endif
     case Js::OpCode::NewScopeSlots:
     case Js::OpCode::NewScopeSlotsWithoutPropIds:
     case Js::OpCode::NewStackScopeSlots:

lib/Backend/Inline.cpp

@@ -139,15 +139,6 @@ Inline::Optimize(Func *func, __in_ecount_opt(callerArgOutCount) IR::Instr *calle
                     JITTimeFunctionBody * body = inlineeData->GetBody();
                     if (!body)
                     {
-#ifdef ENABLE_DOM_FAST_PATH
-                        Assert(inlineeData->GetLocalFunctionId() == Js::JavascriptBuiltInFunction::DOMFastPathGetter ||
-                            inlineeData->GetLocalFunctionId() == Js::JavascriptBuiltInFunction::DOMFastPathSetter);
-                        if (PHASE_OFF1(Js::InlineHostCandidatePhase))
-                        {
-                            break;
-                        }
-                        this->InlineDOMGetterSetterFunction(instr, inlineeData, inlinerData);
-#endif
                         break;
                     }
 
@@ -4180,78 +4171,6 @@ Inline::InlineFunctionCommon(IR::Instr *callInstr, bool originalCallTargetOpndIs
     return instrNext;
 }
 
-#ifdef ENABLE_DOM_FAST_PATH
-// we have LdFld, src1 obj, src2: null; dest: return value
-// We need to convert it to inlined method call.
-// We cannot do CallDirect as it requires ArgOut and that cannot be hoisted/copyprop'd
-// Create a new OpCode, DOMFastPathGetter. The OpCode takes three arguments:
-// The function object, the "this" instance object, and the helper routine as we have one for each index
-// A functionInfo->Index# table is created in scriptContext (and potentially movable to threadContext if WS is not a concern).
-// we use the table to identify the helper that needs to be lowered.
-// At lower time we create the call to helper, which is function entrypoint at this time.
-void Inline::InlineDOMGetterSetterFunction(IR::Instr *ldFldInstr, const FunctionJITTimeInfo *const inlineeData, const FunctionJITTimeInfo *const inlinerData)
-{
-    intptr_t functionInfo = inlineeData->GetFunctionInfoAddr();
-
-    Assert(ldFldInstr->GetSrc1()->IsSymOpnd() && ldFldInstr->GetSrc1()->AsSymOpnd()->IsPropertySymOpnd());
-
-    Assert(ldFldInstr->GetSrc1()->AsPropertySymOpnd()->HasObjTypeSpecFldInfo());
-    Assert(ldFldInstr->GetSrc1()->AsPropertySymOpnd()->GetObjTypeSpecInfo()->UsesAccessor());
-
-    // Find the helper routine for this functionInfo.
-    IR::JnHelperMethod helperMethod = this->topFunc->GetScriptContextInfo()->GetDOMFastPathHelper(functionInfo);
-    if (helperMethod == IR::HelperInvalid)
-    {
-        // abort inlining if helper isn't found
-        return;
-    }
-    // Find the instance object (External object).
-    PropertySym * fieldSym = ldFldInstr->GetSrc1()->AsSymOpnd()->m_sym->AsPropertySym();
-    IR::RegOpnd * instanceOpnd = IR::RegOpnd::New(fieldSym->m_stackSym, TyMachPtr, ldFldInstr->m_func);
-
-    // Find the function object from getter inline cache. Need bailout to verify.
-    IR::Instr *ldMethodFld = IR::Instr::New(Js::OpCode::LdMethodFromFlags, IR::RegOpnd::New(TyVar, ldFldInstr->m_func), ldFldInstr->GetSrc1(), ldFldInstr->m_func);
-    ldFldInstr->InsertBefore(ldMethodFld);
-    ldMethodFld = ldMethodFld->ConvertToBailOutInstr(ldFldInstr, IR::BailOutFailedInlineTypeCheck);
-
-    ldFldInstr->ReplaceSrc1(ldMethodFld->GetDst());
-    ldMethodFld->SetByteCodeOffset(ldFldInstr);
-
-    // generate further object/type bailout
-    PrepareInsertionPoint(ldFldInstr, inlineeData, ldFldInstr);
-
-    // We have three arguments to pass to the OpCode. Create a new ExtendArg_A opcode to chain up the argument. It is similar to ArgOut chain
-    // except that it is not argout.
-    // The Opcode sequence is like:
-    // (dst)helpArg1: ExtendArg_A (src1)thisObject (src2)null
-    // (dst)helpArg2: ExtendArg_A (src1)funcObject (src2)helpArg1
-    // method: DOMFastPathGetter (src1)HelperCall (src2)helpArg2
-    IR::Instr* extendArg0 = IR::Instr::New(Js::OpCode::ExtendArg_A, IR::RegOpnd::New(TyVar, ldFldInstr->m_func), instanceOpnd, ldFldInstr->m_func);
-    ldFldInstr->InsertBefore(extendArg0);
-    IR::Instr* extendArg1 = IR::Instr::New(Js::OpCode::ExtendArg_A, IR::RegOpnd::New(TyVar, ldFldInstr->m_func), ldMethodFld->GetDst(), extendArg0->GetDst(), ldFldInstr->m_func);
-    ldFldInstr->InsertBefore(extendArg1);
-    ldFldInstr->ReplaceSrc1(IR::HelperCallOpnd::New(helperMethod, ldFldInstr->m_func));
-    ldFldInstr->SetSrc2(extendArg1->GetDst());
-    ldFldInstr->m_opcode = Js::OpCode::DOMFastPathGetter;
-
-    StackSym * tmpSym = StackSym::New(ldFldInstr->GetDst()->GetType(), ldFldInstr->m_func);
-    IR::Opnd * tmpDst = IR::RegOpnd::New(tmpSym, tmpSym->GetType(), ldFldInstr->m_func);
-    // Ensure that the original LdFld's dst profile data is also copied to the new instruction for later
-    // type-specific optimizations. Otherwise, this optimization to reduce calls into the host will also
-    // result in relatively more expensive calls in the runtime.
-    tmpDst->SetValueType(ldFldInstr->GetDst()->GetValueType());
-
-    IR::Opnd * callInstrDst = ldFldInstr->UnlinkDst();
-    ldFldInstr->SetDst(tmpDst);
-
-    IR::Instr * ldInstr = IR::Instr::New(Js::OpCode::Ld_A, callInstrDst, tmpDst, ldFldInstr->m_func);
-    ldFldInstr->InsertAfter(ldInstr);
-
-    this->topFunc->SetHasInlinee();
-
-    InsertStatementBoundary(ldInstr->m_next);
-}
-#endif
 void
 Inline::InsertStatementBoundary(IR::Instr * instrNext)
 {

lib/Backend/Inline.h

@@ -65,9 +65,6 @@ private:
                                             bool dontOptimizeJustCheck = false, uint i = 0 /*i-th inlinee at a polymorphic call site*/);
     intptr_t TryOptimizeInstrWithFixedDataProperty(IR::Instr *&instr);
     IR::Instr * InlineScriptFunction(IR::Instr *callInstr, const FunctionJITTimeInfo *const inlineeData, const StackSym *symThis, const Js::ProfileId profileId, bool* pIsInlined, IR::Instr * inlineeDefInstr, uint recursiveInlineDepth);
-#ifdef ENABLE_DOM_FAST_PATH
-    void        InlineDOMGetterSetterFunction(IR::Instr *ldFldInstr, const FunctionJITTimeInfo *const inlineeData, const FunctionJITTimeInfo *const inlinerData);
-#endif
     IR::Instr * InlineGetterSetterFunction(IR::Instr *accessorInstr, const FunctionJITTimeInfo *const inlineeData, const StackSym *symCallerThis, const uint inlineCacheIndex, bool isGetter, bool *pIsInlined, uint recursiveInlineDepth);
     IR::Instr * InlineFunctionCommon(IR::Instr *callInstr, bool originalCallTargetOpndIsJITOpt, StackSym* originalCallTargetStackSym, const FunctionJITTimeInfo *funcInfo, Func *inlinee, IR::Instr *instrNext,
                                 IR::RegOpnd * returnValueOpnd, IR::Instr *inlineBailoutChecksBeforeInstr, const StackSym *symCallerThis, uint recursiveInlineDepth, bool safeThis = false, bool isApplyTarget = false);

lib/Backend/InliningDecider.cpp

@@ -673,12 +673,6 @@ bool InliningDecider::GetBuiltInInfoCommon(
         *returnType = ValueType::GetObject(ObjectType::CharArray);
         break;
 
-#ifdef ENABLE_DOM_FAST_PATH
-    case Js::JavascriptBuiltInFunction::DOMFastPathGetter:
-        *inlineCandidateOpCode = Js::OpCode::DOMFastPathGetter;
-        break;
-#endif
-
     default:
         return false;
     }

lib/Backend/Lower.cpp

@@ -754,12 +754,6 @@ Lowerer::LowerRange(IR::Instr *instrStart, IR::Instr *instrEnd, bool defaultDoFa
             this->GenerateFastInlineBuiltInMathRandom(instr);
             break;
 
-#ifdef ENABLE_DOM_FAST_PATH
-        case Js::OpCode::DOMFastPathGetter:
-            this->LowerFastInlineDOMFastPathGetter(instr);
-            break;
-#endif
-
         case Js::OpCode::InlineArrayPush:
             this->GenerateFastInlineArrayPush(instr);
             break;
@@ -21242,61 +21236,6 @@ Lowerer::GenerateFastInlineStringReplace(IR::Instr * instr)
     return true;
 }
 
-#ifdef ENABLE_DOM_FAST_PATH
-/*
-    Lower the DOMFastPathGetter opcode
-    We have inliner generated bytecode:
-    (dst)helpArg1: ExtendArg_A (src1)thisObject (src2)null
-    (dst)helpArg2: ExtendArg_A (src1)funcObject (src2)helpArg1
-    method: DOMFastPathGetter (src1)HelperCall (src2)helpArg2
-
-    We'll convert it to a JavascriptFunction entry method call:
-    CALL Helper funcObject CallInfo(CallFlags_Value, 3) thisObj
-*/
-void
-Lowerer::LowerFastInlineDOMFastPathGetter(IR::Instr* instr)
-{
-    IR::Opnd* helperOpnd = instr->UnlinkSrc1();
-    Assert(helperOpnd->IsHelperCallOpnd());
-
-    IR::Opnd *linkOpnd = instr->UnlinkSrc2();
-    Assert(linkOpnd->IsRegOpnd());
-
-    IR::Instr* prevInstr = linkOpnd->AsRegOpnd()->m_sym->m_instrDef;
-    Assert(prevInstr->m_opcode == Js::OpCode::ExtendArg_A);
-    IR::Opnd* funcObj = prevInstr->GetSrc1();
-
-    Assert(funcObj->IsRegOpnd());
-    // If the Extended_arg was CSE's across a loop or hoisted out of a loop,
-    // adding a new reference down here might cause funcObj to now be liveOnBackEdge.
-    // Use the addToLiveOnBackEdgeSyms bit vector to add it to a loop if we encounter one.
-    // We'll clear it once we reach the Extended arg.
-    this->addToLiveOnBackEdgeSyms->Set(funcObj->AsRegOpnd()->m_sym->m_id);
-
-    Assert(prevInstr->GetSrc2() != nullptr);
-    prevInstr = prevInstr->GetSrc2()->AsRegOpnd()->m_sym->m_instrDef;
-    Assert(prevInstr->m_opcode == Js::OpCode::ExtendArg_A);
-    IR::Opnd* thisObj = prevInstr->GetSrc1();
-    Assert(prevInstr->GetSrc2() == nullptr);
-
-    Assert(thisObj->IsRegOpnd());
-    this->addToLiveOnBackEdgeSyms->Set(thisObj->AsRegOpnd()->m_sym->m_id);
-
-    const auto info = Lowerer::MakeCallInfoConst(Js::CallFlags_Value, 1, m_func);
-
-    m_lowererMD.LoadHelperArgument(instr, thisObj);
-    m_lowererMD.LoadHelperArgument(instr, info);
-    m_lowererMD.LoadHelperArgument(instr, funcObj);
-
-    instr->m_opcode = Js::OpCode::Call;
-
-    IR::HelperCallOpnd *helperCallOpnd = Lowerer::CreateHelperCallOpnd(helperOpnd->AsHelperCallOpnd()->m_fnHelper, 3, m_func);
-    instr->SetSrc1(helperCallOpnd);
-
-    m_lowererMD.LowerCall(instr, 3);  // we have funcobj, callInfo, and this.
-}
-#endif
-
 void
 Lowerer::GenerateFastInlineArrayPush(IR::Instr * instr)
 {

lib/Backend/Lower.h

@@ -296,9 +296,6 @@ private:
     IR::Instr *     LowerEqualityCompare(IR::Instr* instr, IR::JnHelperMethod helper);
     template <typename ArrayType>
     BOOL            IsSmallObject(uint32 length);
-#ifdef ENABLE_DOM_FAST_PATH
-    void            LowerFastInlineDOMFastPathGetter(IR::Instr* getterInstr);
-#endif
     void            GenerateProfiledNewScIntArrayFastPath(IR::Instr *instr, Js::ArrayCallSiteInfo * arrayInfo, intptr_t arrayInfoAddr, intptr_t weakFuncRef);
     void            GenerateArrayInfoIsNativeIntArrayTest(IR::Instr * instr,  Js::ArrayCallSiteInfo * arrayInfo, intptr_t arrayInfoAddr, IR::LabelInstr * helperLabel);
     void            GenerateProfiledNewScFloatArrayFastPath(IR::Instr *instr, Js::ArrayCallSiteInfo * arrayInfo, intptr_t arrayInfoAddr, intptr_t weakFuncRef);

lib/Backend/NativeCodeGenerator.cpp

@@ -3040,13 +3040,7 @@ NativeCodeGenerator::GatherCodeGenData(
                 const auto inlineeFunctionBody = inlinee->GetFunctionBody();
                 if(!inlineeFunctionBody)
                 {
-                    if ((
-#ifdef ENABLE_DOM_FAST_PATH
-                         inlinee->GetLocalFunctionId() == Js::JavascriptBuiltInFunction::DOMFastPathGetter ||
-                         inlinee->GetLocalFunctionId() == Js::JavascriptBuiltInFunction::DOMFastPathSetter ||
-#endif
-                         (inlineeFunctionInfo->GetAttributes() & Js::FunctionInfo::Attributes::BuiltInInlinableAsLdFldInlinee) != 0) &&
-                        !isJitTimeDataComputed)
+                    if (((inlineeFunctionInfo->GetAttributes() & Js::FunctionInfo::Attributes::BuiltInInlinableAsLdFldInlinee) != 0) && !isJitTimeDataComputed)
                     {
                         jitTimeData->AddLdFldInlinee(recycler, inlineCacheIndex, inlinee);
                     }

lib/Backend/ServerScriptContext.cpp

@@ -24,7 +24,6 @@ ServerScriptContext::ServerScriptContext(ScriptContextDataIDL * contextData, Ser
     m_sourceCodeArena(_u("JITSourceCodeArena"), threadContextInfo->GetForegroundPageAllocator(), Js::Throw::OutOfMemory, nullptr),
     m_interpreterThunkBufferManager(&m_sourceCodeArena, threadContextInfo->GetThunkPageAllocators(), nullptr, threadContextInfo, _u("Interpreter thunk buffer"), GetThreadContext()->GetProcessHandle()),
     m_asmJsInterpreterThunkBufferManager(&m_sourceCodeArena, threadContextInfo->GetThunkPageAllocators(), nullptr, threadContextInfo, _u("Asm.js interpreter thunk buffer"), GetThreadContext()->GetProcessHandle()),
-    m_domFastPathHelperMap(nullptr),
     m_moduleRecords(&HeapAllocator::Instance),
     m_codeGenAlloc(nullptr, nullptr, threadContextInfo, threadContextInfo->GetCodePageAllocators(), threadContextInfo->GetProcessHandle()),
     m_globalThisAddr(0),
@@ -38,13 +37,10 @@ ServerScriptContext::ServerScriptContext(ScriptContextDataIDL * contextData, Ser
 #if !TARGET_64 && _CONTROL_FLOW_GUARD
     m_codeGenAlloc.canCreatePreReservedSegment = threadContextInfo->CanCreatePreReservedSegment();
 #endif
-
-    m_domFastPathHelperMap = HeapNew(JITDOMFastPathHelperMap, &HeapAllocator::Instance, 17);
 }
 
 ServerScriptContext::~ServerScriptContext()
 {
-    HeapDelete(m_domFastPathHelperMap);
     m_moduleRecords.Map([](uint, Js::ServerSourceTextModuleRecord* record)
     {
         HeapDelete(record);
@@ -321,13 +317,6 @@ ServerScriptContext::IsClosed() const
     return m_isClosed;
 }
 
-void
-ServerScriptContext::AddToDOMFastPathHelperMap(intptr_t funcInfoAddr, IR::JnHelperMethod helper)
-{
-    AutoCriticalSection cs(&m_cs);
-    m_domFastPathHelperMap->Add(funcInfoAddr, helper);
-}
-
 ArenaAllocator *
 ServerScriptContext::GetSourceCodeArena()
 {
@@ -353,18 +342,6 @@ ServerScriptContext::GetEmitBufferManager(bool asmJsManager)
     }
 }
 
-IR::JnHelperMethod
-ServerScriptContext::GetDOMFastPathHelper(intptr_t funcInfoAddr)
-{
-    AutoCriticalSection cs(&m_cs);
-
-    IR::JnHelperMethod helper = IR::HelperInvalid;
-
-    m_domFastPathHelperMap->TryGetValue(funcInfoAddr, &helper);
-
-    return helper;
-}
-
 void
 ServerScriptContext::Close()
 {

lib/Backend/ServerScriptContext.h

@@ -70,10 +70,6 @@ public:
     virtual bool IsRecyclerVerifyEnabled() const override;
     virtual uint GetRecyclerVerifyPad() const override;
 
-    virtual void AddToDOMFastPathHelperMap(intptr_t funcInfoAddr, IR::JnHelperMethod helper) override;
-    virtual IR::JnHelperMethod GetDOMFastPathHelper(intptr_t funcInfoAddr) override;
-
-
     typedef JsUtil::BaseDictionary<uint, Js::ServerSourceTextModuleRecord*, Memory::HeapAllocator> ServerModuleRecords;
     ServerModuleRecords m_moduleRecords;
 
@@ -97,7 +93,6 @@ public:
     void Release();
 
 private:
-    JITDOMFastPathHelperMap * m_domFastPathHelperMap;
 #ifdef PROFILE_EXEC
     Js::ScriptContextProfiler * codeGenProfiler;
     CriticalSection profilerCS;

lib/Common/CommonDefines.h

@@ -335,7 +335,6 @@
 #define ENABLE_WININET_PROFILE_DATA_CACHE
 #define ENABLE_COMPRESSION_UTILITIES
 #define ENABLE_BASIC_TELEMETRY
-#define ENABLE_DOM_FAST_PATH
 #define EDIT_AND_CONTINUE
 #define ENABLE_JIT_CLAMP
 #define ENABLE_SCRIPT_PROFILING

lib/Common/ConfigFlagsList.h

@@ -335,7 +335,6 @@ PHASE(All)
         PHASE(CloneCacheInCollision)
         PHASE(ConstructorCache)
         PHASE(InlineCandidate)
-        PHASE(InlineHostCandidate)
         PHASE(ScriptFunctionWithInlineCache)
         PHASE(IsConcatSpreadableCache)
         PHASE(Arena)

lib/JITClient/JITManager.cpp

@@ -403,28 +403,6 @@ JITManager::CleanupThreadContext(
     return hr;
 }
 
-HRESULT
-JITManager::AddDOMFastPathHelper(
-    __in PSCRIPTCONTEXT_HANDLE scriptContextInfoAddress,
-    __in intptr_t funcInfoAddr,
-    __in int helper)
-{
-    Assert(IsOOPJITEnabled());
-
-    HRESULT hr = E_FAIL;
-    RpcTryExcept
-    {
-        hr = ClientAddDOMFastPathHelper(m_rpcBindingHandle, scriptContextInfoAddress, funcInfoAddr, helper);
-    }
-    RpcExcept(RpcExceptionFilter(RpcExceptionCode()))
-    {
-        hr = HRESULT_FROM_WIN32(RpcExceptionCode());
-    }
-    RpcEndExcept;
-
-    return hr;
-}
-
 HRESULT
 JITManager::SetIsPRNGSeeded(
     __in PSCRIPTCONTEXT_HANDLE scriptContextInfoAddress,

lib/JITClient/JITManager.h

@@ -53,11 +53,6 @@ public:
         __in InterpreterThunkInputIDL * thunkInput,
         __out InterpreterThunkOutputIDL * thunkOutput);
 
-    HRESULT AddDOMFastPathHelper(
-        __in PSCRIPTCONTEXT_HANDLE scriptContextInfoAddress,
-        __in intptr_t funcInfoAddr,
-        __in int helper);
-
     HRESULT AddModuleRecordInfo(
             /* [in] */ PSCRIPTCONTEXT_HANDLE scriptContextInfoAddress,
             /* [in] */ unsigned int moduleId,
@@ -181,12 +176,6 @@ public:
         __in_opt BVSparseNodeIDL * updatedPropsBVHead)
         { Assert(false); return E_FAIL; }
 
-    HRESULT AddDOMFastPathHelper(
-        __in PSCRIPTCONTEXT_HANDLE scriptContextInfoAddress,
-        __in intptr_t funcInfoAddr,
-        __in int helper)
-        { Assert(false); return E_FAIL; }
-
     HRESULT AddModuleRecordInfo(
             /* [in] */ PSCRIPTCONTEXT_HANDLE scriptContextInfoAddress,
             /* [in] */ unsigned int moduleId,

lib/JITIDL/ChakraJIT.acf

@@ -9,7 +9,6 @@
 interface IChakraJIT
 {
     UpdatePropertyRecordMap([context_handle_noserialize] threadContextInfoAddress);
-    AddDOMFastPathHelper([context_handle_noserialize] scriptContextInfoAddress);
     AddModuleRecordInfo([context_handle_noserialize] scriptContextInfoAddress);
     SetWellKnownHostTypeId([context_handle_noserialize] threadContextInfoAddress);
     CloseScriptContext([context_handle_noserialize] scriptContextInfoAddress);

lib/JITIDL/ChakraJIT.idl

@@ -58,12 +58,6 @@ interface IChakraJIT
         [in] PTHREADCONTEXT_HANDLE threadContextInfoAddress,
         [in, unique] BVSparseNodeIDL * updatedPropsBVHead);
 
-    HRESULT AddDOMFastPathHelper(
-        [in] handle_t binding,
-        [in] PSCRIPTCONTEXT_HANDLE scriptContextInfoAddress,
-        [in] CHAKRA_PTR funcInfoAddr,
-        [in] int helper);
-
     HRESULT AddModuleRecordInfo(
         [in] handle_t binding,
         [in] PSCRIPTCONTEXT_HANDLE scriptContextInfoAddress,

lib/JITServer/JITServer.cpp

@@ -341,33 +341,6 @@ ServerUpdatePropertyRecordMap(
     });
 }
 
-HRESULT
-ServerAddDOMFastPathHelper(
-    /* [in] */ handle_t binding,
-    /* [in] */ __RPC__in PSCRIPTCONTEXT_HANDLE scriptContextInfoAddress,
-    /* [in] */ intptr_t funcInfoAddr,
-    /* [in] */ int helper)
-{
-    ServerScriptContext * scriptContextInfo = (ServerScriptContext*)DecodePointer(scriptContextInfoAddress);
-
-    if (scriptContextInfo == nullptr)
-    {
-        Assert(false);
-        return RPC_S_INVALID_ARG;
-    }
-    if (helper < 0 || helper >= IR::JnHelperMethodCount)
-    {
-        Assert(UNREACHED);
-        return E_ACCESSDENIED;
-    }
-
-    return ServerCallWrapper(scriptContextInfo, [&]()->HRESULT
-    {
-        scriptContextInfo->AddToDOMFastPathHelperMap(funcInfoAddr, (IR::JnHelperMethod)helper);
-        return S_OK;
-    });
-}
-
 HRESULT
 ServerAddModuleRecordInfo(
     /* [in] */ handle_t binding,

lib/Runtime/Base/CrossSite.h

@@ -4,13 +4,11 @@
 //-------------------------------------------------------------------------------------------------------
 #pragma once
 
-class DOMFastPathInfo;
 namespace Js
 {
     class CrossSite
     {
         friend class ExternalType;
-        friend class DOMFastPathInfo;
     public:
         static bool IsThunk(JavascriptMethod thunk);
         static BOOL NeedMarshalVar(Var instance, ScriptContext * requestContext);

lib/Runtime/Base/ScriptContext.cpp

@@ -80,7 +80,6 @@ namespace Js
 #endif
 #if ENABLE_NATIVE_CODEGEN
         nativeCodeGen(nullptr),
-        m_domFastPathHelperMap(nullptr),
         m_remoteScriptContextAddr(nullptr),
         jitFuncRangeCache(nullptr),
 #endif
@@ -366,9 +365,6 @@ namespace Js
         intConstPropsOnGlobalObject = Anew(GeneralAllocator(), PropIdSetForConstProp, GeneralAllocator());
         intConstPropsOnGlobalUserObject = Anew(GeneralAllocator(), PropIdSetForConstProp, GeneralAllocator());
 
-#if ENABLE_NATIVE_CODEGEN
-        m_domFastPathHelperMap = HeapNew(JITDOMFastPathHelperMap, &HeapAllocator::Instance, 17);
-#endif
 #ifdef ENABLE_SCRIPT_DEBUGGING
         this->debugContext = HeapNew(DebugContext, this);
 #endif
@@ -425,13 +421,6 @@ namespace Js
         // Take etw rundown lock on this thread context. We are going to change/destroy this scriptContext.
         AutoCriticalSection autocs(GetThreadContext()->GetFunctionBodyLock());
 
-#if ENABLE_NATIVE_CODEGEN
-        if (m_domFastPathHelperMap != nullptr)
-        {
-            HeapDelete(m_domFastPathHelperMap);
-        }
-#endif
-
         // TODO: Can we move this on Close()?
         ClearHostScriptContext();
 
@@ -5631,24 +5620,6 @@ ScriptContext::GetJitFuncRangeCache()
         return (intptr_t)this;
     }
 
-#if ENABLE_NATIVE_CODEGEN
-    void ScriptContext::AddToDOMFastPathHelperMap(intptr_t funcInfoAddr, IR::JnHelperMethod helper)
-    {
-        m_domFastPathHelperMap->Add(funcInfoAddr, helper);
-    }
-
-    IR::JnHelperMethod ScriptContext::GetDOMFastPathHelper(intptr_t funcInfoAddr)
-    {
-        IR::JnHelperMethod helper = IR::HelperInvalid;
-
-        m_domFastPathHelperMap->LockResize();
-        m_domFastPathHelperMap->TryGetValue(funcInfoAddr, &helper);
-        m_domFastPathHelperMap->UnlockResize();
-
-        return helper;
-    }
-#endif
-
     intptr_t ScriptContext::GetVTableAddress(VTableValue vtableType) const
     {
         Assert(vtableType < VTableValue::Count);

lib/Runtime/Base/ScriptContext.h

@@ -1855,12 +1855,6 @@ private:
 #endif
 
         virtual intptr_t GetChakraLibAddr() const override;
-
-#if ENABLE_NATIVE_CODEGEN
-        virtual void AddToDOMFastPathHelperMap(intptr_t funcInfoAddr, IR::JnHelperMethod helper) override;
-        virtual IR::JnHelperMethod GetDOMFastPathHelper(intptr_t funcInfoAddr) override;
-#endif
-
         virtual intptr_t GetAddr() const override;
 
         virtual intptr_t GetVTableAddress(VTableValue vtableType) const override;
@@ -1881,10 +1875,6 @@ private:
     private:
         BuiltInLibraryFunctionMap* builtInLibraryFunctions;
 
-#if ENABLE_NATIVE_CODEGEN
-        JITDOMFastPathHelperMap * m_domFastPathHelperMap;
-#endif
-
 #ifdef RECYCLER_PERF_COUNTERS
         size_t bindReferenceCount;
 #endif

lib/Runtime/Base/ScriptContextInfo.h

@@ -61,12 +61,4 @@ public:
 
     virtual intptr_t GetChakraLibAddr() const = 0;
 
-#if ENABLE_NATIVE_CODEGEN
-    virtual void AddToDOMFastPathHelperMap(intptr_t funcInfoAddr, IR::JnHelperMethod helper) = 0;
-    virtual IR::JnHelperMethod GetDOMFastPathHelper(intptr_t funcInfoAddr) = 0;
-
-    typedef JsUtil::BaseDictionary<intptr_t, IR::JnHelperMethod, HeapAllocator, PowerOf2SizePolicy,
-        DefaultComparer, JsUtil::SimpleDictionaryEntry, JsUtil::AsymetricResizeLock> JITDOMFastPathHelperMap;
-#endif
-
 };

lib/Runtime/ByteCode/OpCodes.h

@@ -803,11 +803,6 @@ MACRO_BACKEND_ONLY(     CheckObjType,        Empty,          OpFastFldInstr|OpTe
 MACRO_BACKEND_ONLY(     AdjustObjType,       Empty,          OpSideEffect)
 MACRO_BACKEND_ONLY(     AdjustObjTypeReloadAuxSlotPtr,       Empty,          OpSideEffect)
 
-                                                                                                            // Edge inline built-ins
-#ifdef ENABLE_DOM_FAST_PATH
-MACRO_BACKEND_ONLY(     DOMFastPathGetter,   Empty,          OpCanCSE)  // unlike other builtins, we don't know the return type
-MACRO_BACKEND_ONLY(     DOMFastPathSetter,   Empty,          OpSideEffect)
-#endif
 MACRO_BACKEND_ONLY(     ExtendArg_A,         Empty,          OpCanCSE)  // extend a list of arguments to be passed to functions.
 
 #ifdef _M_X64

lib/Runtime/Library/JavascriptBuiltInFunctions.h

@@ -14,10 +14,6 @@ namespace Js
 #define BUILTIN(c, n, e, i) c ## _ ## n,
 #include "JavascriptBuiltInFunctionList.h"
 #undef BUILTIN
-#ifdef ENABLE_DOM_FAST_PATH
-            DOMFastPathGetter,
-            DOMFastPathSetter,
-#endif
             MaxBuiltInEnum
         };
         static FunctionInfo * GetFunctionInfo(Js::LocalFunctionId builtinId);