Lines Matching defs:object
84 // Name must be a symbol and receiver must be a heap object.
241 // Load the global or builtins object from the current context.
244 // Load the global context from the global or builtins object.
282 // Check that the object is a JS array.
292 // Generate code to check if an object is a string. If the object is
299 // Check that the object isn't a smi.
302 // Check that the object is a string.
319 // Check if the object is a string leaving the instance type in the
329 // Check if the object is a JSValue wrapper.
355 // Load a fast property out of a holder object (src). In-object properties
384 __ Move(kScratchRegister, Handle<Object>(interceptor));
455 // -- rsp[8] : object passing the type check
473 Object* call_data = optimization.api_call_info()->data();
480 __ Move(Operand(rsp, 3 * kPointerSize), Handle<Object>(call_data));
486 Object* callback = optimization.api_call_info()->callback();
515 // object.
531 JSObject* object,
550 object,
562 object,
576 JSObject* object,
595 optimization.GetPrototypeDepthOfExpectedType(object,
619 stub_compiler_->CheckPrototypes(object, receiver,
640 // for API (object which is instanceof for the signature). It's
674 JSObject* object,
683 stub_compiler_->CheckPrototypes(object, receiver, interceptor_holder,
753 JSObject* object,
760 // Check that the object isn't a smi.
763 // Check that the map of the object hasn't changed.
765 Handle<Map>(object->map()));
769 if (object->IsJSGlobalProxy()) {
775 ASSERT(object->IsJSGlobalProxy() || !object->IsAccessCheckNeeded());
778 if ((transition != NULL) && (object->map()->unused_property_fields() == 0)) {
795 // Update the map of the object; no write barrier updating is
801 // Adjust for the number of properties stored in the object. Even in the
803 // object and the number of in-object properties is not going to change.
804 index -= object->map()->inobject_properties();
807 // Set the property straight into the object.
808 int offset = object->map()->instance_size() + (index * kPointerSize);
842 Object* probe;
848 __ Move(scratch, Handle<Object>(cell));
860 Register StubCompiler::CheckPrototypes(JSObject* object,
869 // Make sure there's no overlap between holder and object registers.
874 // Keep track of the current object in register reg. On the first
885 // Traverse the prototype chain from the object and do map checks.
886 JSObject* current = object;
917 reg = holder_reg; // from now the object is in holder_reg
920 // Get the map of the current object.
925 // Check access rights to the global object. This has to happen
926 // after the map check so that we know that the object is
927 // actually a global object.
931 // Restore scratch register to be the map of the object.
937 reg = holder_reg; // from now the object is in holder_reg
941 // Check the map of the current object.
946 // Check access rights to the global object. This has to happen
947 // after the map check so that we know that the object is
948 // actually a global object.
953 reg = holder_reg; // from now the object is in holder_reg
961 // Go to the next object in the prototype chain.
972 // Perform security check for access to the global object and return
983 current = object;
1004 void StubCompiler::GenerateLoadField(JSObject* object,
1018 CheckPrototypes(object, receiver, holder,
1027 MaybeObject* StubCompiler::GenerateLoadCallback(JSObject* object,
1042 CheckPrototypes(object, receiver, holder, scratch1,
1057 __ Push(Handle<Object>(callback_handle->data()));
1099 // object.
1104 void StubCompiler::GenerateLoadConstant(JSObject* object,
1110 Object* value,
1118 CheckPrototypes(object, receiver, holder,
1122 __ Move(rax, Handle<Object>(value));
1127 void StubCompiler::GenerateLoadInterceptor(JSObject* object,
1161 Register holder_reg = CheckPrototypes(object, receiver, interceptor_holder,
1251 Register holder_reg = CheckPrototypes(object, receiver, interceptor_holder,
1274 void CallStubCompiler::GenerateGlobalReceiverCheck(JSObject* object,
1286 // If the object is the holder then we know that it's a global
1287 // object which can only happen for contextual calls. In this case,
1289 if (object != holder) {
1294 CheckPrototypes(object, rdx, holder, rbx, rax, rdi, name, miss);
1330 Object* obj;
1337 MaybeObject* CallStubCompiler::CompileCallField(JSObject* object,
1362 Register reg = CheckPrototypes(object, rdx, holder, rbx, rax, rdi,
1374 if (object->IsGlobalObject()) {
1392 MaybeObject* CallStubCompiler::CompileArrayPushCall(Object* object,
1405 // If object is not an array, bail out to regular call.
1406 if (!object->IsJSArray() || cell != NULL) return heap()->undefined_value();
1419 CheckPrototypes(JSObject::cast(object),
1435 // Get the elements array of the object.
1553 MaybeObject* CallStubCompiler::CompileArrayPopCall(Object* object,
1566 // If object is not an array, bail out to regular call.
1567 if (!object->IsJSArray() || cell != NULL) return heap()->undefined_value();
1580 CheckPrototypes(JSObject::cast(object), rdx,
1584 // Get the elements array of the object.
1637 Object* object,
1650 // If object is not a string, bail out to regular call.
1651 if (!object->IsString() || cell != NULL) return heap()->undefined_value();
1671 ASSERT(object != holder);
1672 CheckPrototypes(JSObject::cast(object->GetPrototype()), rax, holder,
1719 Object* object,
1732 // If object is not a string, bail out to regular call.
1733 if (!object->IsString() || cell != NULL) return heap()->undefined_value();
1753 ASSERT(object != holder);
1754 CheckPrototypes(JSObject::cast(object->GetPrototype()), rax, holder,
1803 Object* object,
1818 // If the object is not a JSObject or we got an unexpected number of
1820 if (!object->IsJSObject() || argc != 1) return heap()->undefined_value();
1830 CheckPrototypes(JSObject::cast(object), rdx, holder, rbx, rax, rdi, name,
1834 GenerateGlobalReceiverCheck(JSObject::cast(object), holder, name, &miss);
1871 MaybeObject* CallStubCompiler::CompileMathFloorCall(Object* object,
1881 MaybeObject* CallStubCompiler::CompileMathAbsCall(Object* object,
1896 // If the object is not a JSObject or we got an unexpected number of
1898 if (!object->IsJSObject() || argc != 1) return heap()->undefined_value();
1908 CheckPrototypes(JSObject::cast(object), rdx, holder, rbx, rax, rdi, name,
1912 GenerateGlobalReceiverCheck(JSObject::cast(object), holder, name, &miss);
1986 Object* object,
1992 // Bail out if object is a global object as we don't want to
1994 if (object->IsGlobalObject()) return heap()->undefined_value();
1997 JSObject::cast(object), holder);
2020 CheckPrototypes(JSObject::cast(object), rdx, holder,
2042 MaybeObject* CallStubCompiler::CompileCallConstant(Object* object,
2059 object, holder, NULL, function, name);
2060 Object* result;
2081 ASSERT(!object->IsGlobalObject() || check == RECEIVER_MAP_CHECK);
2090 CheckPrototypes(JSObject::cast(object), rdx, holder,
2095 if (object->IsGlobalObject()) {
2107 // Check that the object is a two-byte string or a symbol.
2113 CheckPrototypes(JSObject::cast(object->GetPrototype()), rax, holder,
2125 // Check that the object is a smi or a heap number.
2133 CheckPrototypes(JSObject::cast(object->GetPrototype()), rax, holder,
2146 // Check that the object is a boolean.
2155 CheckPrototypes(JSObject::cast(object->GetPrototype()), rax, holder,
2177 MaybeObject* CallStubCompiler::CompileCallInterceptor(JSObject* object,
2204 object,
2225 if (object->IsGlobalObject()) {
2244 MaybeObject* CallStubCompiler::CompileCallGlobal(JSObject* object,
2261 object, holder, cell, function, name);
2262 Object* result;
2275 GenerateGlobalReceiverCheck(object, holder, name, &miss);
2280 if (object->IsGlobalObject()) {
2315 MaybeObject* StoreStubCompiler::CompileStoreField(JSObject* object,
2329 object,
2345 MaybeObject* StoreStubCompiler::CompileStoreCallback(JSObject* object,
2356 // Check that the object isn't a smi.
2359 // Check that the map of the object hasn't changed.
2361 Handle<Map>(object->map()));
2365 if (object->IsJSGlobalProxy()) {
2371 ASSERT(object->IsJSGlobalProxy() || !object->IsAccessCheckNeeded());
2405 // Check that the object isn't a smi.
2408 // Check that the map of the object hasn't changed.
2444 MaybeObject* StoreStubCompiler::CompileStoreGlobal(GlobalObject* object,
2457 Handle<Map>(object->map()));
2463 // global object. We bail out to the runtime system to do that.
2488 MaybeObject* KeyedStoreStubCompiler::CompileStoreField(JSObject* object,
2509 object,
2584 JSObject* object,
2597 // global property cells up to (but not including) the last object
2599 CheckPrototypes(object, rax, last, rbx, rdx, rdi, name, &miss);
2601 // If the last object in the prototype chain is a global object,
2628 MaybeObject* LoadStubCompiler::CompileLoadField(JSObject* object,
2639 GenerateLoadField(object, holder, rax, rbx, rdx, rdi, index, name, &miss);
2649 JSObject* object,
2659 MaybeObject* result = GenerateLoadCallback(object, holder, rax, rcx, rdx, rbx,
2674 MaybeObject* LoadStubCompiler::CompileLoadConstant(JSObject* object,
2676 Object* value,
2685 GenerateLoadConstant(object, holder, rax, rbx, rdx, rdi, value, name, &miss);
2728 MaybeObject* LoadStubCompiler::CompileLoadGlobal(JSObject* object,
2740 // If the object is the holder then we know that it's a global
2741 // object which can only happen for contextual loads. In this case,
2743 if (object != holder) {
2748 CheckPrototypes(object, rax, holder, rbx, rdx, rdi, name, &miss);
2845 Object* value) {
3092 // Load the address of the first in-object property into r9.
3102 // r9: first in-object property of the JSObject
3119 Handle<Object> constant(shared->GetThisPropertyAssignmentConstant(i));
3124 // Fill the unused in-object property fields with undefined.
3172 // Check that the object isn't a smi.
3301 // Check that the object isn't a smi.
