Remove Unboxed Object code from /vm, Part 3.

1 files changed, 6 insertions, 136 deletions

diff --git a/js/src/vm/TypeInference.cpp b/js/src/vm/TypeInference.cpp
index 0551e2c58..26ade2948 100644
--- a/js/src/vm/TypeInference.cpp
+++ b/js/src/vm/TypeInference.cpp
@@ -35,7 +35,6 @@
 #include "vm/Opcodes.h"
 #include "vm/Shape.h"
 #include "vm/Time.h"
-#include "vm/UnboxedObject.h"
 
 #include "jsatominlines.h"
 #include "jsscriptinlines.h"
@@ -297,9 +296,6 @@ js::ObjectGroupHasProperty(JSContext* cx, ObjectGroup* group, jsid id, const Val
                         return true;
                 }
             }
-            JSObject* obj = &value.toObject();
-            if (!obj->hasLazyGroup() && obj->group()->maybeOriginalUnboxedGroup())
-                return true;
         }
 
         if (!types->hasType(type)) {
@@ -1944,33 +1940,6 @@ class ConstraintDataFreezeObjectForTypedArrayData
     }
 };
 
-// Constraint which triggers recompilation if an unboxed object in some group
-// is converted to a native object.
-class ConstraintDataFreezeObjectForUnboxedConvertedToNative
-{
-  public:
-    ConstraintDataFreezeObjectForUnboxedConvertedToNative()
-    {}
-
-    const char* kind() { return "freezeObjectForUnboxedConvertedToNative"; }
-
-    bool invalidateOnNewType(TypeSet::Type type) { return false; }
-    bool invalidateOnNewPropertyState(TypeSet* property) { return false; }
-    bool invalidateOnNewObjectState(ObjectGroup* group) {
-        return group->unboxedLayout().nativeGroup() != nullptr;
-    }
-
-    bool constraintHolds(JSContext* cx,
-                         const HeapTypeSetKey& property, TemporaryTypeSet* expected)
-    {
-        return !invalidateOnNewObjectState(property.object()->maybeGroup());
-    }
-
-    bool shouldSweep() { return false; }
-
-    JSCompartment* maybeCompartment() { return nullptr; }
-};
-
 } /* anonymous namespace */
 
 void
@@ -2505,8 +2474,6 @@ TemporaryTypeSet::propertyNeedsBarrier(CompilerConstraintList* constraints, jsid
 bool
 js::ClassCanHaveExtraProperties(const Class* clasp)
 {
-    if (clasp == &UnboxedPlainObject::class_)
-        return false;
     return clasp->getResolve()
         || clasp->getOpsLookupProperty()
         || clasp->getOpsGetProperty()
@@ -2805,15 +2772,6 @@ js::AddTypePropertyId(ExclusiveContext* cx, ObjectGroup* group, JSObject* obj, j
     // from acquiring the fully initialized group.
     if (group->newScript() && group->newScript()->initializedGroup())
         AddTypePropertyId(cx, group->newScript()->initializedGroup(), nullptr, id, type);
-
-    // Maintain equivalent type information for unboxed object groups and their
-    // corresponding native group. Since type sets might contain the unboxed
-    // group but not the native group, this ensures optimizations based on the
-    // unboxed group are valid for the native group.
-    if (group->maybeUnboxedLayout() && group->maybeUnboxedLayout()->nativeGroup())
-        AddTypePropertyId(cx, group->maybeUnboxedLayout()->nativeGroup(), nullptr, id, type);
-    if (ObjectGroup* unboxedGroup = group->maybeOriginalUnboxedGroup())
-        AddTypePropertyId(cx, unboxedGroup, nullptr, id, type);
 }
 
 void
@@ -2885,12 +2843,6 @@ ObjectGroup::setFlags(ExclusiveContext* cx, ObjectGroupFlags flags)
     // acquired properties analysis.
     if (newScript() && newScript()->initializedGroup())
         newScript()->initializedGroup()->setFlags(cx, flags);
-
-    // Propagate flag changes between unboxed and corresponding native groups.
-    if (maybeUnboxedLayout() && maybeUnboxedLayout()->nativeGroup())
-        maybeUnboxedLayout()->nativeGroup()->setFlags(cx, flags);
-    if (ObjectGroup* unboxedGroup = maybeOriginalUnboxedGroup())
-        unboxedGroup->setFlags(cx, flags);
 }
 
 void
@@ -2923,13 +2875,6 @@ ObjectGroup::markUnknown(ExclusiveContext* cx)
             prop->types.setNonDataProperty(cx);
         }
     }
-
-    if (ObjectGroup* unboxedGroup = maybeOriginalUnboxedGroup())
-        MarkObjectGroupUnknownProperties(cx, unboxedGroup);
-    if (maybeUnboxedLayout() && maybeUnboxedLayout()->nativeGroup())
-        MarkObjectGroupUnknownProperties(cx, maybeUnboxedLayout()->nativeGroup());
-    if (ObjectGroup* unboxedGroup = maybeOriginalUnboxedGroup())
-        MarkObjectGroupUnknownProperties(cx, unboxedGroup);
 }
 
 TypeNewScript*
@@ -2937,8 +2882,6 @@ ObjectGroup::anyNewScript()
 {
     if (newScript())
         return newScript();
-    if (maybeUnboxedLayout())
-        return unboxedLayout().newScript();
     return nullptr;
 }
 
@@ -2968,10 +2911,7 @@ ObjectGroup::detachNewScript(bool writeBarrier, ObjectGroup* replacement)
         MOZ_ASSERT(!replacement);
     }
 
-    if (this->newScript())
-        setAddendum(Addendum_None, nullptr, writeBarrier);
-    else
-        unboxedLayout().setNewScript(nullptr, writeBarrier);
+    setAddendum(Addendum_None, nullptr, writeBarrier);
 }
 
 void
@@ -3451,22 +3391,6 @@ PreliminaryObjectArray::sweep()
     for (size_t i = 0; i < COUNT; i++) {
         JSObject** ptr = &objects[i];
         if (*ptr && IsAboutToBeFinalizedUnbarriered(ptr)) {
-            // Before we clear this reference, change the object's group to the
-            // Object.prototype group. This is done to ensure JSObject::finalize
-            // sees a NativeObject Class even if we change the current group's
-            // Class to one of the unboxed object classes in the meantime. If
-            // the compartment's global is dead, we don't do anything as the
-            // group's Class is not going to change in that case.
-            JSObject* obj = *ptr;
-            GlobalObject* global = obj->compartment()->unsafeUnbarrieredMaybeGlobal();
-            if (global && !obj->isSingleton()) {
-                JSObject* objectProto = GetBuiltinPrototypePure(global, JSProto_Object);
-                obj->setGroup(objectProto->groupRaw());
-                MOZ_ASSERT(obj->is<NativeObject>());
-                MOZ_ASSERT(obj->getClass() == objectProto->getClass());
-                MOZ_ASSERT(!obj->getClass()->hasFinalize());
-            }
-
             *ptr = nullptr;
         }
     }
@@ -3566,16 +3490,11 @@ PreliminaryObjectArrayWithTemplate::maybeAnalyze(ExclusiveContext* cx, ObjectGro
         }
     }
 
-    if (group->maybeUnboxedLayout())
-        return;
-
-    if (shape()) {
-        // We weren't able to use an unboxed layout, but since the preliminary
-        // objects still reflect the template object's properties, and all
-        // objects in the future will be created with those properties, the
-        // properties can be marked as definite for objects in the group.
-        group->addDefiniteProperties(cx, shape());
-    }
+    // Since the preliminary objects still reflect the template object's
+    // properties, and all objects in the future will be created with those
+    // properties, the properties can be marked as definitive for objects in
+    // the group.
+    group->addDefiniteProperties(cx, shape());
 }
 
 /////////////////////////////////////////////////////////////////////
@@ -3589,7 +3508,6 @@ TypeNewScript::make(JSContext* cx, ObjectGroup* group, JSFunction* fun)
 {
     MOZ_ASSERT(cx->zone()->types.activeAnalysis);
     MOZ_ASSERT(!group->newScript());
-    MOZ_ASSERT(!group->maybeUnboxedLayout());
 
     // rollbackPartiallyInitializedObjects expects function_ to be
     // canonicalized.
@@ -3852,27 +3770,6 @@ TypeNewScript::maybeAnalyze(JSContext* cx, ObjectGroup* group, bool* regenerate,
     js_delete(preliminaryObjects);
     preliminaryObjects = nullptr;
 
-    if (group->maybeUnboxedLayout()) {
-        // An unboxed layout was constructed for the group, and this has already
-        // been hooked into it.
-        MOZ_ASSERT(group->unboxedLayout().newScript() == this);
-        destroyNewScript.group = nullptr;
-
-        // Clear out the template object, which is not used for TypeNewScripts
-        // with an unboxed layout. Currently it is a mutant object with a
-        // non-native group and native shape, so make it safe for GC by changing
-        // its group to the default for its prototype.
-        AutoEnterOOMUnsafeRegion oomUnsafe;
-        ObjectGroup* plainGroup = ObjectGroup::defaultNewGroup(cx, &PlainObject::class_,
-                                                               group->proto());
-        if (!plainGroup)
-            oomUnsafe.crash("TypeNewScript::maybeAnalyze");
-        templateObject_->setGroup(plainGroup);
-        templateObject_ = nullptr;
-
-        return true;
-    }
-
     if (prefixShape->slotSpan() == templateObject()->slotSpan()) {
         // The definite properties analysis found exactly the properties that
         // are held in common by the preliminary objects. No further analysis
@@ -3968,12 +3865,6 @@ TypeNewScript::rollbackPartiallyInitializedObjects(JSContext* cx, ObjectGroup* g
             continue;
         }
 
-        if (thisv.toObject().is<UnboxedPlainObject>()) {
-            AutoEnterOOMUnsafeRegion oomUnsafe;
-            if (!UnboxedPlainObject::convertToNative(cx, &thisv.toObject()))
-                oomUnsafe.crash("rollbackPartiallyInitializedObjects");
-        }
-
         // Found a matching frame.
         RootedPlainObject obj(cx, &thisv.toObject().as<PlainObject>());
 
@@ -4167,12 +4058,6 @@ ConstraintTypeSet::sweep(Zone* zone, AutoClearTypeInferenceStateOnOOM& oom)
                 // Object sets containing objects with unknown properties might
                 // not be complete. Mark the type set as unknown, which it will
                 // be treated as during Ion compilation.
-                //
-                // Note that we don't have to do this when the type set might
-                // be missing the native group corresponding to an unboxed
-                // object group. In this case, the native group points to the
-                // unboxed object group via its addendum, so as long as objects
-                // with either group exist, neither group will be finalized.
                 flags |= TYPE_FLAG_ANYOBJECT;
                 clearObjects();
                 objectCount = 0;
@@ -4256,21 +4141,6 @@ ObjectGroup::sweep(AutoClearTypeInferenceStateOnOOM* oom)
     Maybe<AutoClearTypeInferenceStateOnOOM> fallbackOOM;
     EnsureHasAutoClearTypeInferenceStateOnOOM(oom, zone(), fallbackOOM);
 
-    if (maybeUnboxedLayout()) {
-        // Remove unboxed layouts that are about to be finalized from the
-        // compartment wide list while we are still on the main thread.
-        ObjectGroup* group = this;
-        if (IsAboutToBeFinalizedUnbarriered(&group))
-            unboxedLayout().detachFromCompartment();
-
-        if (unboxedLayout().newScript())
-            unboxedLayout().newScript()->sweep();
-
-        // Discard constructor code to avoid holding onto ExecutablePools.
-        if (zone()->isGCCompacting())
-            unboxedLayout().setConstructorCode(nullptr);
-    }
-
     if (maybePreliminaryObjects())
         maybePreliminaryObjects()->sweep();