Disable fixed field and equivalent type spec code from DISABLE_JIT builds

Put equivalent type spec and property guard code under ENABLE_NATIVE_CODEGEN
Also fixed ability to disable SUPPORT_FIXED_FIELDS_ON_PATH_TYPES
Disable fixed field for when JIT is disabled.

Reduced binary size of the lite build by ~41K on x86 and ~65K on x64.

Author: curtisman

lib/Backend/InterpreterThunkEmitter.cpp

@@ -4,7 +4,7 @@
 //-------------------------------------------------------------------------------------------------------
 #include "Backend.h"
 
-#ifdef ENABLE_NATIVE_CODEGEN
+#if ENABLE_NATIVE_CODEGEN
 #ifdef _M_X64
 #ifdef _WIN32
 const BYTE InterpreterThunkEmitter::FunctionInfoOffset = 23;

lib/Backend/InterpreterThunkEmitter.h

@@ -4,7 +4,7 @@
 //-------------------------------------------------------------------------------------------------------
 #pragma once
 
-#ifdef ENABLE_NATIVE_CODEGEN
+#if ENABLE_NATIVE_CODEGEN
 class ThunkBlock
 {
 private:

lib/Backend/NativeCodeGenerator.cpp

@@ -2733,6 +2733,7 @@ NativeCodeGenerator::GatherCodeGenData(
             }
 
             Js::JavascriptFunction* fixedFunctionObject = nullptr;
+#if ENABLE_FIXED_FIELDS
             if (inlineCache && (inlineCache->IsLocal() || inlineCache->IsProto()))
             {
                 inlineCache->TryGetFixedMethodFromCache(functionBody, ldFldInlineCacheIndex, &fixedFunctionObject);
@@ -2742,6 +2743,7 @@ NativeCodeGenerator::GatherCodeGenData(
             {
                 fixedFunctionObject = nullptr;
             }
+#endif
 
             if (!PHASE_OFF(Js::InlineRecursivePhase, functionBody))
             {

lib/Backend/ObjTypeSpecFldInfo.cpp

@@ -275,7 +275,9 @@ ObjTypeSpecFldInfo* ObjTypeSpecFldInfo::CreateFrom(uint id, Js::InlineCache* cac
     bool isLocal = localCache.IsLocal();
     bool isProto = localCache.IsProto();
     bool isAccessor = localCache.IsAccessor();
+#if ENABLE_FIXED_FIELDS
     bool isGetter = localCache.IsGetterAccessor();
+#endif
     if (isLocal)
     {
         type = TypeWithoutAuxSlotTag(localCache.u.local.type);
@@ -372,6 +374,7 @@ ObjTypeSpecFldInfo* ObjTypeSpecFldInfo::CreateFrom(uint id, Js::InlineCache* cac
     Assert(entryPoint->GetJitTransferData() != nullptr);
     entryPoint->GetJitTransferData()->AddJitTimeTypeRef(type, recycler);
 
+#if ENABLE_FIXED_FIELDS
     bool allFixedPhaseOFF = PHASE_OFF(Js::FixedMethodsPhase, topFunctionBody) & PHASE_OFF(Js::UseFixedDataPropsPhase, topFunctionBody);
 
     if (!allFixedPhaseOFF)
@@ -534,6 +537,7 @@ ObjTypeSpecFldInfo* ObjTypeSpecFldInfo::CreateFrom(uint id, Js::InlineCache* cac
             }
         }
     }
+#endif
 
     FixedFieldInfo * fixedFieldInfoArray = RecyclerNewArrayZ(recycler, FixedFieldInfo, 1);
 
@@ -756,7 +760,12 @@ ObjTypeSpecFldInfo* ObjTypeSpecFldInfo::CreateFrom(uint id, Js::PolymorphicInlin
         areEquivalent = areStressEquivalent = false;
     }
 
+#if ENABLE_FIXED_FIELDS
     gatherDataForInlining = gatherDataForInlining && (typeCount <= 4); // Only support 4-way (max) polymorphic inlining
+#else
+    gatherDataForInlining = false;
+#endif
+
     if (!areEquivalent && !areStressEquivalent)
     {
         IncInlineCacheCount(nonEquivPolyInlineCacheCount);
@@ -786,6 +795,7 @@ ObjTypeSpecFldInfo* ObjTypeSpecFldInfo::CreateFrom(uint id, Js::PolymorphicInlin
     // as the allocation may trigger a GC which can clear the inline caches.
     FixedFieldInfo localFixedFieldInfoArray[Js::DynamicProfileInfo::maxPolymorphicInliningSize] = {};
 
+#if ENABLE_FIXED_FIELDS
     // For polymorphic field loads we only support fixed functions on prototypes. This helps keep the equivalence check helper simple.
     // Since all types in the polymorphic cache share the same prototype, it's enough to grab the fixed function from the prototype object.
     Js::Var fixedProperty = nullptr;
@@ -805,12 +815,11 @@ ObjTypeSpecFldInfo* ObjTypeSpecFldInfo::CreateFrom(uint id, Js::PolymorphicInlin
 
         // TODO (ObjTypeSpec): Enable constructor caches on equivalent polymorphic field loads with fixed functions.
     }
-
+#endif
     // Let's get the types.
     Js::Type* localTypes[MaxPolymorphicInlineCacheSize];
 
     uint16 typeNumber = 0;
-    Js::JavascriptFunction* fixedFunctionObject = nullptr;
     for (uint16 i = firstNonEmptyCacheIndex; i < polyCacheSize; i++)
     {
         Js::InlineCache& inlineCache = inlineCaches[i];
@@ -820,8 +829,10 @@ ObjTypeSpecFldInfo* ObjTypeSpecFldInfo::CreateFrom(uint id, Js::PolymorphicInlin
             inlineCache.IsProto() ? TypeWithoutAuxSlotTag(inlineCache.u.proto.type) :
             TypeWithoutAuxSlotTag(inlineCache.u.accessor.type);
 
+#if ENABLE_FIXED_FIELDS
         if (gatherDataForInlining)
         {
+            Js::JavascriptFunction* fixedFunctionObject = nullptr;
             inlineCache.TryGetFixedMethodFromCache(functionBody, cacheId, &fixedFunctionObject);
             if (!fixedFunctionObject || !fixedFunctionObject->GetFunctionInfo()->HasBody())
             {
@@ -845,7 +856,7 @@ ObjTypeSpecFldInfo* ObjTypeSpecFldInfo::CreateFrom(uint id, Js::PolymorphicInlin
 
             fixedFunctionCount++;
         }
-
+#endif
         typeNumber++;
     }
 

lib/Common/CommonDefines.h

@@ -12,6 +12,7 @@
 #include "Warnings.h"
 #include "ChakraCoreVersion.h"
 
+
 //----------------------------------------------------------------------------------------------------
 // Default debug/fretest/release flags values
 //  - Set the default values of debug/fretest/release flags if it is not set by the command line
@@ -122,7 +123,15 @@
 
 // Type system features
 #define PERSISTENT_INLINE_CACHES                    // *** TODO: Won't build if disabled currently
-#define SUPPORT_FIXED_FIELDS_ON_PATH_TYPES          // *** TODO: Won't build if disabled currently
+
+#if !DISABLE_JIT
+#define ENABLE_FIXED_FIELDS 1                       // Turn on fixed fields if JIT is enabled
+#endif
+
+#if ENABLE_FIXED_FIELDS
+#define SUPPORT_FIXED_FIELDS_ON_PATH_TYPES
+#endif
+
 
 // xplat-todo: revisit these features
 #ifdef _WIN32

lib/Runtime/Base/FunctionBody.h

@@ -79,6 +79,8 @@ namespace Js
         Type * type;
         void * data;
     };
+
+#if ENABLE_NATIVE_CODEGEN
     class PropertyGuard
     {
         friend class PropertyGuardValidator;
@@ -271,6 +273,7 @@ namespace Js
             this->cache = cache;
         }
     };
+#endif // ENABLE_NATIVE_CODEGEN
 
 #pragma region Inline Cache Info class declarations
     class PolymorphicCacheUtilizationArray

lib/Runtime/Base/ThreadContext.cpp

@@ -88,7 +88,9 @@ ThreadContext::RecyclableData::RecyclableData(Recycler *const recycler) :
     oomErrorObject(nullptr, nullptr, nullptr, true),
     terminatedErrorObject(nullptr, nullptr, nullptr),
     typesWithProtoPropertyCache(recycler),
+#if ENABLE_NATIVE_CODEGEN
     propertyGuards(recycler, 128),
+#endif
     oldEntryPointInfo(nullptr),
 #ifdef ENABLE_SCRIPT_DEBUGGING
     returnedValueList(nullptr),
@@ -3099,6 +3101,7 @@ ThreadContext::ClearInlineCachesWithDeadWeakRefs()
     }
 }
 
+#if ENABLE_NATIVE_CODEGEN
 void
 ThreadContext::ClearInvalidatedUniqueGuards()
 {
@@ -3131,6 +3134,7 @@ ThreadContext::ClearInvalidatedUniqueGuards()
         });
     });
 }
+#endif
 
 void
 ThreadContext::ClearInlineCaches()

lib/Runtime/Base/ThreadContext.h

@@ -572,14 +572,15 @@ class ThreadContext sealed :
         // that would not get removed, but it would also not get any bigger.
         Field(PropertyIdToTypeHashSetDictionary) typesWithProtoPropertyCache;
 
+#if ENABLE_NATIVE_CODEGEN
         // The property guard dictionary contains property guards which need to be invalidated in response to properties changing
         // from writable to read-only and vice versa, properties being shadowed or unshadowed on prototypes, etc.  The dictionary
         // holds only weak references to property guards and their lifetimes are controlled by their creators (typically entry points).
         // When a guard is no longer needed it is garbage collected, but the weak references and dictionary entries remain, until
         // the guards for a given property get invalidated.
         // TODO: Create and use a self-cleaning weak reference dictionary, which would periodically remove any unused weak references.
         Field(PropertyGuardDictionary) propertyGuards;
-
+#endif
 
         Field(PropertyNoCaseSetType *) caseInvariantPropertySet;
 

lib/Runtime/Language/CacheOperators.cpp

@@ -38,9 +38,11 @@ namespace Js
             (RootObjectBase::Is(objectWithProperty) && propertyIndex == RootObjectBase::FromVar(objectWithProperty)->GetRootPropertyIndex(propertyId)));
         Assert(DynamicType::Is(objectWithProperty->GetTypeId()));
 
+#if ENABLE_FIXED_FIELDS
         // We are populating a cache guarded by the instance's type (not the type of the object with property somewhere in the prototype chain),
         // so we only care if the instance's property (if any) is fixed.
         Assert(info->IsNoCache() || !info->IsStoreFieldCacheEnabled() || info->GetInstance() != objectWithProperty || !objectWithProperty->IsFixedProperty(propertyId));
+#endif
 
         PropertyIndex slotIndex;
         bool isInlineSlot;
@@ -210,7 +212,9 @@ namespace Js
         {
             AssertMsg(instance == object, "invalid instance for non setter");
             Assert(DynamicType::Is(typeWithoutProperty->GetTypeId()));
+#if ENABLE_FIXED_FIELDS
             Assert(info->IsNoCache() || !info->IsStoreFieldCacheEnabled() || object->CanStorePropertyValueDirectly(propertyId, isRoot));
+#endif
             Assert(info->IsWritable());
 
             DynamicType* newType = (DynamicType*)object->GetType();

lib/Runtime/Language/InlineCache.cpp

@@ -413,6 +413,7 @@ namespace Js
         return clone;
     }
 
+#if ENABLE_FIXED_FIELDS
     bool InlineCache::TryGetFixedMethodFromCache(Js::FunctionBody* functionBody, uint cacheId, Js::JavascriptFunction** pFixedMethod)
     {
         Assert(pFixedMethod);
@@ -464,6 +465,7 @@ namespace Js
 
         return false;
     }
+#endif
 
     void InlineCache::CopyTo(PropertyId propertyId, ScriptContext * scriptContext, InlineCache * const clone)
     {