Updating object proto representation to use TaggedProto

Author: abhishekc-sharma

notes/cacheir.cachet

@@ -578,24 +578,22 @@ ir CacheIR emits MASM {
 
         CacheIR::addFailurePath(out label failure);
 
-        label loopHead: MASM;
         label returnFalse: MASM;
         label returnTrue: MASM;
         label done: MASM;
 
-        emit MASM::BranchTestObject(Condition::NotEqual, lhsReg, returnFalse);
-        emit MASM::UnboxObject(lhsReg, scratchReg);
-        emit MASM::LoadObjectProto(scratchReg, lhsReg);
+        emit MASM::FallibleUnboxObject(lhsReg, scratchReg, failure);
+        emit MASM::LoadObjectProto(scratchReg, scratchReg);
 
+        label loopHead: MASM;
         bind loopHead;
-        emit MASM::BranchTestNull(Condition::Equal, lhsReg, returnFalse);
-        emit MASM::BranchTestMagic(Condition::Equal, lhsReg, failure);
 
-        emit MASM::BranchTestObject(Condition::NotEqual, lhsReg, returnFalse);
-        emit MASM::UnboxObject(lhsReg, scratchReg);
+        emit MASM::BranchTestNullProto(scratchReg, returnFalse);
+        emit MASM::BranchTestLazyProto(scratchReg, failure);
+        emit MASM::UnboxObjectProto(scratchReg, scratchReg);
         emit MASM::BranchObject(Condition::Equal, scratchReg, protoReg, returnTrue);
 
-        emit MASM::LoadObjectProto(scratchReg, lhsReg);
+        emit MASM::LoadObjectProto(scratchReg, scratchReg);
         //emit MASM::StoreBool(true, protoReg); <-- uncomment to induce error
         emit MASM::Jump(loopHead);
 

notes/js.cachet

@@ -9,6 +9,7 @@ enum RegDataType {
     NativeObjectSlots,
     NativeObjectElements,
     TypeTag,
+    TaggedProto,
 }
 
 struct RegData;
@@ -126,6 +127,28 @@ impl RegData {
 
     unsafe fn toValueTypeUnchecked(data: RegData) -> ValueType;
 
+    fn isTaggedProto(data: RegData) -> Bool {
+        RegData::typeOf(data) == RegDataType::TaggedProto
+    }
+
+    fn fromTaggedProto(proto: TaggedProto) -> RegData {
+        let data = (unsafe { RegData::fromTaggedProtoUnchecked(proto) });
+        assume RegData::isTaggedProto(data);
+        assume (unsafe { RegData::toTaggedProtoUnchecked(data) }) == proto;
+        data
+    }
+
+    unsafe fn fromTaggedProtoUnchecked(proto: TaggedProto) -> RegData;
+
+    fn toTaggedProto(data: RegData) -> TaggedProto {
+        assert RegData::isTaggedProto(data);
+        let proto = (unsafe { RegData::toTaggedProtoUnchecked(data) });
+        assume (unsafe { RegData::fromTaggedProtoUnchecked(proto) }) == data;
+        proto
+    }
+
+    unsafe fn toTaggedProtoUnchecked(data: RegData) -> TaggedProto;
+
     fn readData(data: RegData, offset: Int64) -> RegData {
         if RegData::isUnboxedValue(data) {
             let value = RegData::toUnboxedValue(data);
@@ -355,13 +378,7 @@ impl Object {
 
     unsafe fn shapeOfUnchecked(heap: Heap, object: Object) -> Shape;
 
-    // #[reads(heap)]
-    // fn protoOf(object: Object) -> Value;
-    fn protoOf(object: Object) -> Value {
-        (unsafe { Object::protoOfUnchecked(heap, object) })
-    }
-
-    unsafe fn protoOfUnchecked(heap: Heap, object: Object) -> Value;
+    
 
     fn toNativeObject(object: Object) -> NativeObject {
         let shape = Object::shapeOf(object);
@@ -617,6 +634,14 @@ struct BaseShape;
 
 impl BaseShape {
     fn classOf(baseShape: BaseShape) -> Class;
+
+    // #[reads(heap)]
+    // fn protoOf(object: Object) -> TaggedProto;
+    fn protoOf(baseShape: BaseShape) -> TaggedProto {
+        (unsafe { BaseShape::protoOfUnchecked(heap, baseShape) })
+    }
+
+    unsafe fn protoOfUnchecked(heap: Heap, baseShape: BaseShape) -> TaggedProto;
 }
 
 struct Shape;
@@ -668,3 +693,34 @@ struct String;
 struct Symbol;
 
 struct BigInt;
+
+enum ProtoTag {
+    Null,
+    Lazy,
+    Object,
+}
+
+struct TaggedProto;
+
+impl TaggedProto {
+    fn tag(proto: TaggedProto) -> ProtoTag;
+
+    fn isNull(proto: TaggedProto) -> Bool {
+        TaggedProto::tag(proto) == ProtoTag::Null
+    }
+
+    fn isLazy(proto: TaggedProto) -> Bool {
+        TaggedProto::tag(proto) == ProtoTag::Lazy
+    }
+
+    fn isObject(proto: TaggedProto) -> Bool {
+        TaggedProto::tag(proto) == ProtoTag::Object
+    }
+
+    fn toObject(proto: TaggedProto) -> Object {
+        assert TaggedProto::isObject(proto);
+        (unsafe { TaggedProto::toObjectUnchecked(proto) })
+    }
+
+    unsafe fn toObjectUnchecked(proto: TaggedProto) -> Object;
+}

notes/masm.cachet

@@ -231,6 +231,28 @@ ir MASM {
         MASM::setObject(objectReg, Value::toObject(value));
     }
 
+    // Note: this is a no-op in Firefox since TaggedProtos
+    // can be directly treated as Objects without explicit
+    // unboxing.
+    op UnboxObjectProto(srcReg: Reg, destReg: Reg) {
+        let data = MASM::getData(srcReg);
+        let proto = RegData::toTaggedProto(data);
+        let object = TaggedProto::toObject(proto);
+        MASM::setObject(destReg, object);
+    } 
+
+    op FallibleUnboxObject(valueReg: ValueReg, objectReg: Reg, label failure: MASM) {
+        let value = MASM::getValue(valueReg);
+        let valueIsObject = Value::isObject(value);
+
+        if !valueIsObject {
+            goto failure;
+        }
+
+        let object = Value::toObject(value);
+        MASM::setObject(objectReg, object);
+    }
+
     op FallibleUnboxBoolean(valueReg: ValueReg, boolReg: Reg, label failure: MASM) {
         let value = MASM::getValue(valueReg);
         let valueIsBool = Value::isBool(value);
@@ -456,6 +478,28 @@ ir MASM {
       }
     }
 
+    // Note: this is a wrapper around branchTestPtr for when
+    // the register contains a TaggedProto
+    op BranchTestNullProto(reg: Reg, label branch: MASM) {
+        let data = MASM::getData(reg);
+        let proto = RegData::toTaggedProto(data);
+
+        if TaggedProto::isNull(proto) {
+            goto branch;
+        }
+    }
+
+    // Note: this is a wrapper around branchPtr for when
+    // the register contains a TaggedProto
+    op BranchTestLazyProto(reg: Reg, label branch: MASM) {
+        let data = MASM::getData(reg);
+        let proto = RegData::toTaggedProto(data);
+
+        if TaggedProto::isLazy(proto) {
+            goto branch;
+        }
+    }
+
     op BranchTestNull(condition: Condition, valueReg: ValueReg, label branch: MASM) {
         let value = MASM::getValue(valueReg);
         let valueIsNull = Value::isNull(value);
@@ -937,9 +981,15 @@ ir MASM {
         MASM::setInt32(outputReg, length)
     }
 
-    op LoadObjectProto(objectReg: Reg, protoReg: ValueReg) {
+    op LoadObjectProto(objectReg: Reg, protoReg: Reg) {
         let object = MASM::getObject(objectReg);
-        MASM::setValue(protoReg, Object::protoOf(object));
+
+        let shape = Object::shapeOf(object);
+        let baseShape = Shape::baseShapeOf(shape);
+        let proto = BaseShape::protoOf(baseShape);
+        let data = RegData::fromTaggedProto(proto);
+
+        MASM::setData(protoReg, data);
     }
 
     fn getData(reg: Reg) -> RegData;

notes/stubs/instanceof.cachet

@@ -1,11 +1,10 @@
 import "../cacheir.cachet"
+import "../utils.cachet"
 
 ir CacheStub emits CacheIR {
     op InstanceOf(lhsId: ValueId, rhsId: ValueId) {
-        CacheIR::initValueInput(lhsId);
-        CacheIR::defineValueReg(lhsId);
-        CacheIR::initValueInput(rhsId);
-        CacheIR::defineValueReg(rhsId);
+        initValueInput(lhsId);
+        initValueInput(rhsId);
 
         emit CacheIR::GuardToObject(rhsId);
         let protoId = ValueId::toObjectId(rhsId);