Lines Matching refs:__
45 #define __ ACCESS_MASM(masm_)
63 __ test(reg, Immediate(kSmiTagMask));
70 __ test(reg, Immediate(kSmiTagMask));
78 __ test(eax, Immediate(delta_to_patch_site));
83 __ nop(); // Signals no inlined code.
92 __ bind(&patch_site_);
93 __ j(cc, target, distance);
136 __ int3();
146 __ test(ecx, ecx);
147 __ j(zero, &ok, Label::kNear);
150 __ mov(ecx, Operand(esp, receiver_offset));
151 __ JumpIfSmi(ecx, &ok);
152 __ CmpObjectType(ecx, JS_GLOBAL_PROXY_TYPE, ecx);
153 __ j(not_equal, &ok, Label::kNear);
154 __ mov(Operand(esp, receiver_offset),
156 __ bind(&ok);
164 __ push(ebp); // Caller's frame pointer.
165 __ mov(ebp, esp);
166 __ push(esi); // Callee's context.
167 __ push(edi); // Callee's JS Function.
172 __ push(Immediate(isolate()->factory()->undefined_value()));
174 __ mov(eax, Immediate(isolate()->factory()->undefined_value()));
176 __ push(eax);
188 __ push(edi);
191 __ CallStub(&stub);
193 __ CallRuntime(Runtime::kNewFunctionContext, 1);
198 __ mov(Operand(ebp, StandardFrameConstants::kContextOffset), esi);
208 __ mov(eax, Operand(ebp, parameter_offset));
211 __ mov(Operand(esi, context_offset), eax);
213 __ RecordWriteContextSlot(esi,
227 __ push(edi);
229 __ push(Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
234 __ lea(edx,
236 __ push(edx);
237 __ SafePush(Immediate(Smi::FromInt(num_parameters)));
251 __ CallStub(&stub);
257 __ CallRuntime(Runtime::kTraceEnter, 0);
286 __ cmp(esp, Operand::StaticVariable(stack_limit));
287 __ j(above_equal, &ok, Label::kNear);
289 __ CallStub(&stub);
290 __ bind(&ok);
303 __ mov(eax, isolate()->factory()->undefined_value());
310 __ Set(eax, Immediate(Smi::FromInt(0)));
315 __ mov(ebx, Immediate(profiling_counter_));
316 __ sub(FieldOperand(ebx, JSGlobalPropertyCell::kValueOffset),
331 __ mov(ebx, Immediate(profiling_counter_));
332 __ mov(FieldOperand(ebx, JSGlobalPropertyCell::kValueOffset),
355 __ j(positive, &ok, Label::kNear);
357 __ CallStub(&stub);
364 __ cmp(esp, Operand::StaticVariable(stack_limit));
365 __ j(above_equal, &ok, Label::kNear);
367 __ CallStub(&stub);
380 __ test(eax, Immediate(Min(loop_depth(), Code::kMaxLoopNestingMarker)));
386 __ bind(&ok);
398 __ jmp(&return_label_);
401 __ bind(&return_label_);
403 __ push(eax);
404 __ CallRuntime(Runtime::kTraceExit, 1);
418 __ j(positive, &ok, Label::kNear);
419 __ push(eax);
421 __ push(Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
422 __ CallRuntime(Runtime::kOptimizeFunctionOnNextCall, 1);
425 __ CallStub(&stub);
427 __ pop(eax);
429 __ bind(&ok);
437 __ RecordJSReturn();
440 __ mov(esp, ebp);
441 __ pop(ebp);
444 __ Ret(arguments_bytes, ecx);
470 __ push(operand);
511 __ SafeSet(result_register(), Immediate(lit));
513 __ Set(result_register(), Immediate(lit));
520 __ SafePush(Immediate(lit));
522 __ push(Immediate(lit));
534 if (false_label_ != fall_through_) __ jmp(false_label_);
536 if (true_label_ != fall_through_) __ jmp(true_label_);
539 if (false_label_ != fall_through_) __ jmp(false_label_);
541 if (true_label_ != fall_through_) __ jmp(true_label_);
545 if (false_label_ != fall_through_) __ jmp(false_label_);
547 if (true_label_ != fall_through_) __ jmp(true_label_);
551 __ mov(result_register(), lit);
560 __ Drop(count);
568 __ Drop(count);
569 __ Move(result_register(), reg);
576 if (count > 1) __ Drop(count - 1);
577 __ mov(Operand(esp, 0), reg);
585 __ Drop(count);
586 __ Move(result_register(), reg);
595 __ bind(materialize_true);
603 __ bind(materialize_true);
604 __ mov(result_register(), isolate()->factory()->true_value());
605 __ jmp(&done, Label::kNear);
606 __ bind(materialize_false);
607 __ mov(result_register(), isolate()->factory()->false_value());
608 __ bind(&done);
616 __ bind(materialize_true);
617 __ push(Immediate(isolate()->factory()->true_value()));
618 __ jmp(&done, Label::kNear);
619 __ bind(materialize_false);
620 __ push(Immediate(isolate()->factory()->false_value()));
621 __ bind(&done);
640 __ mov(result_register(), value);
648 __ push(Immediate(value));
658 if (true_label_ != fall_through_) __ jmp(true_label_);
660 if (false_label_ != fall_through_) __ jmp(false_label_);
670 __ push(result_register());
671 __ CallStub(&stub, condition->test_id());
672 __ test(result_register(), result_register());
683 __ j(cc, if_true);
685 __ j(NegateCondition(cc), if_false);
687 __ j(cc, if_true);
688 __ jmp(if_false);
711 __ LoadContext(scratch, context_chain_length);
722 __ mov(dest, location);
735 __ mov(location, src);
741 __ RecordWriteContextSlot(scratch0, offset, src, scratch1, kDontSaveFPRegs);
756 if (should_normalize) __ jmp(&skip, Label::kNear);
759 __ cmp(eax, isolate()->factory()->true_value());
761 __ bind(&skip);
785 __ mov(StackOperand(variable), result_register());
788 __ mov(StackOperand(variable),
799 __ mov(ebx, FieldOperand(esi, HeapObject::kMapOffset));
800 __ cmp(ebx, isolate()->factory()->with_context_map());
801 __ Check(not_equal, "Declaration in with context.");
802 __ cmp(ebx, isolate()->factory()->catch_context_map());
803 __ Check(not_equal, "Declaration in catch context.");
808 __ mov(ContextOperand(esi, variable->index()), result_register());
810 __ RecordWriteContextSlot(esi,
820 __ mov(ContextOperand(esi, variable->index()),
829 __ push(esi);
830 __ push(Immediate(variable->name()));
838 __ push(Immediate(Smi::FromInt(attr)));
846 __ push(Immediate(isolate()->factory()->the_hole_value()));
848 __ push(Immediate(Smi::FromInt(0))); // Indicates no initial value.
850 __ CallRuntime(Runtime::kDeclareContextSlot, 4);
859 __ push(esi); // The context is the first argument.
860 __ push(Immediate(pairs));
861 __ push(Immediate(Smi::FromInt(DeclareGlobalsFlags())));
862 __ CallRuntime(Runtime::kDeclareGlobals, 3);
892 __ bind(&next_test);
899 __ mov(edx, Operand(esp, 0)); // Switch value.
904 __ mov(ecx, edx);
905 __ or_(ecx, eax);
908 __ cmp(edx, eax);
909 __ j(not_equal, &next_test);
910 __ Drop(1); // Switch value is no longer needed.
911 __ jmp(clause->body_target());
912 __ bind(&slow_case);
920 __ test(eax, eax);
921 __ j(not_equal, &next_test);
922 __ Drop(1); // Switch value is no longer needed.
923 __ jmp(clause->body_target());
928 __ bind(&next_test);
929 __ Drop(1); // Switch value is no longer needed.
931 __ jmp(nested_statement.break_label());
933 __ jmp(default_clause->body_target());
940 __ bind(clause->body_target());
945 __ bind(nested_statement.break_label());
962 __ cmp(eax, isolate()->factory()->undefined_value());
963 __ j(equal, &exit);
964 __ cmp(eax, isolate()->factory()->null_value());
965 __ j(equal, &exit);
971 __ JumpIfSmi(eax, &convert, Label::kNear);
972 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
973 __ j(above_equal, &done_convert, Label::kNear);
974 __ bind(&convert);
975 __ push(eax);
976 __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
977 __ bind(&done_convert);
978 __ push(eax);
983 __ CmpObjectType(eax, LAST_JS_PROXY_TYPE, ecx);
984 __ j(below_equal, &call_runtime);
990 __ CheckEnumCache(&call_runtime);
992 __ mov(eax, FieldOperand(eax, HeapObject::kMapOffset));
993 __ jmp(&use_cache, Label::kNear);
996 __ bind(&call_runtime);
997 __ push(eax);
998 __ CallRuntime(Runtime::kGetPropertyNamesFast, 1);
999 __ cmp(FieldOperand(eax, HeapObject::kMapOffset),
1001 __ j(not_equal, &fixed_array);
1005 __ bind(&use_cache);
1006 __ LoadInstanceDescriptors(eax, ecx);
1007 __ mov(ecx, FieldOperand(ecx, DescriptorArray::kEnumerationIndexOffset));
1008 __ mov(edx, FieldOperand(ecx, DescriptorArray::kEnumCacheBridgeCacheOffset));
1011 __ push(eax); // Map.
1012 __ push(edx); // Enumeration cache.
1013 __ mov(eax, FieldOperand(edx, FixedArray::kLengthOffset));
1014 __ push(eax); // Enumeration cache length (as smi).
1015 __ push(Immediate(Smi::FromInt(0))); // Initial index.
1016 __ jmp(&loop);
1020 __ bind(&fixed_array);
1027 __ LoadHeapObject(ebx, cell);
1028 __ mov(FieldOperand(ebx, JSGlobalPropertyCell::kValueOffset),
1031 __ mov(ebx, Immediate(Smi::FromInt(1))); // Smi indicates slow check
1032 __ mov(ecx, Operand(esp, 0 * kPointerSize)); // Get enumerated object
1034 __ CmpObjectType(ecx, LAST_JS_PROXY_TYPE, ecx);
1035 __ j(above, &non_proxy);
1036 __ mov(ebx, Immediate(Smi::FromInt(0))); // Zero indicates proxy
1037 __ bind(&non_proxy);
1038 __ push(ebx); // Smi
1039 __ push(eax); // Array
1040 __ mov(eax, FieldOperand(eax, FixedArray::kLengthOffset));
1041 __ push(eax); // Fixed array length (as smi).
1042 __ push(Immediate(Smi::FromInt(0))); // Initial index.
1046 __ bind(&loop);
1047 __ mov(eax, Operand(esp, 0 * kPointerSize)); // Get the current index.
1048 __ cmp(eax, Operand(esp, 1 * kPointerSize)); // Compare to the array length.
1049 __ j(above_equal, loop_statement.break_label());
1052 __ mov(ebx, Operand(esp, 2 * kPointerSize));
1053 __ mov(ebx, FieldOperand(ebx, eax, times_2, FixedArray::kHeaderSize));
1057 __ mov(edx, Operand(esp, 3 * kPointerSize));
1062 __ mov(ecx, Operand(esp, 4 * kPointerSize));
1063 __ cmp(edx, FieldOperand(ecx, HeapObject::kMapOffset));
1064 __ j(equal, &update_each, Label::kNear);
1069 __ test(edx, edx);
1070 __ j(zero, &update_each);
1075 __ push(ecx); // Enumerable.
1076 __ push(ebx); // Current entry.
1077 __ InvokeBuiltin(Builtins::FILTER_KEY, CALL_FUNCTION);
1078 __ test(eax, eax);
1079 __ j(equal, loop_statement.continue_label());
1080 __ mov(ebx, eax);
1084 __ bind(&update_each);
1085 __ mov(result_register(), ebx);
1096 __ bind(loop_statement.continue_label());
1097 __ add(Operand(esp, 0 * kPointerSize), Immediate(Smi::FromInt(1)));
1100 __ jmp(&loop);
1103 __ bind(loop_statement.break_label());
1104 __ add(esp, Immediate(5 * kPointerSize));
1108 __ bind(&exit);
1127 __ push(Immediate(info));
1128 __ CallStub(&stub);
1130 __ push(esi);
1131 __ push(Immediate(info));
1132 __ push(Immediate(pretenure
1135 __ CallRuntime(Runtime::kNewClosure, 3);
1158 __ cmp(ContextOperand(context, Context::EXTENSION_INDEX),
1160 __ j(not_equal, slow);
1163 __ mov(temp, ContextOperand(context, Context::PREVIOUS_INDEX));
1179 __ mov(temp, context);
1181 __ bind(&next);
1183 __ cmp(FieldOperand(temp, HeapObject::kMapOffset),
1185 __ j(equal, &fast, Label::kNear);
1187 __ cmp(ContextOperand(temp, Context::EXTENSION_INDEX), Immediate(0));
1188 __ j(not_equal, slow);
1190 __ mov(temp, ContextOperand(temp, Context::PREVIOUS_INDEX));
1191 __ jmp(&next);
1192 __ bind(&fast);
1197 __ mov(eax, GlobalObjectOperand());
1198 __ mov(ecx, var->name());
1217 __ cmp(ContextOperand(context, Context::EXTENSION_INDEX),
1219 __ j(not_equal, slow);
1221 __ mov(temp, ContextOperand(context, Context::PREVIOUS_INDEX));
1227 __ cmp(ContextOperand(context, Context::EXTENSION_INDEX), Immediate(0));
1228 __ j(not_equal, slow);
1248 __ jmp(done);
1251 __ mov(eax, ContextSlotOperandCheckExtensions(local, slow));
1255 __ cmp(eax, isolate()->factory()->the_hole_value());
1256 __ j(not_equal, done);
1258 __ mov(eax, isolate()->factory()->undefined_value());
1260 __ push(Immediate(var->name()));
1261 __ CallRuntime(Runtime::kThrowReferenceError, 1);
1264 __ jmp(done);
1281 __ mov(eax, GlobalObjectOperand());
1282 __ mov(ecx, var->name());
1334 __ cmp(eax, isolate()->factory()->the_hole_value());
1335 __ j(not_equal, &done, Label::kNear);
1339 __ push(Immediate(var->name()));
1340 __ CallRuntime(Runtime::kThrowReferenceError, 1);
1344 __ mov(eax, isolate()->factory()->undefined_value());
1346 __ bind(&done);
1360 __ bind(&slow);
1362 __ push(esi); // Context.
1363 __ push(Immediate(var->name()));
1364 __ CallRuntime(Runtime::kLoadContextSlot, 2);
1365 __ bind(&done);
1381 __ mov(edi, Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
1382 __ mov(ecx, FieldOperand(edi, JSFunction::kLiteralsOffset));
1385 __ mov(ebx, FieldOperand(ecx, literal_offset));
1386 __ cmp(ebx, isolate()->factory()->undefined_value());
1387 __ j(not_equal, &materialized, Label::kNear);
1391 __ push(ecx);
1392 __
1393 __ push(Immediate(expr->pattern()));
1394 __ push(Immediate(expr->flags()));
1395 __ CallRuntime(Runtime::kMaterializeRegExpLiteral, 4);
1396 __ mov(ebx, eax);
1398 __ bind(&materialized);
1401 __ AllocateInNewSpace(size, eax, ecx, edx, &runtime_allocate, TAG_OBJECT);
1402 __ jmp(&allocated);
1404 __ bind(&runtime_allocate);
1405 __ push(ebx);
1406 __ push(Immediate(Smi::FromInt(size)));
1407 __ CallRuntime(Runtime::kAllocateInNewSpace, 1);
1408 __ pop(ebx);
1410 __ bind(&allocated);
1414 __ mov(edx, FieldOperand(ebx, i));
1415 __ mov(ecx, FieldOperand(ebx, i + kPointerSize));
1416 __ mov(FieldOperand(eax, i), edx);
1417 __ mov(FieldOperand(eax, i + kPointerSize), ecx);
1420 __ mov(edx, FieldOperand(ebx, size - kPointerSize));
1421 __ mov(FieldOperand(eax, size - kPointerSize), edx);
1429 __ push(Immediate(isolate()->factory()->null_value()));
1439 __ mov(edi, Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
1440 __ push(FieldOperand(edi, JSFunction::kLiteralsOffset));
1441 __ push(Immediate(Smi::FromInt(expr->literal_index())));
1442 __ push(Immediate(constant_properties));
1449 __ push(Immediate(Smi::FromInt(flags)));
1452 __ CallRuntime(Runtime::kCreateObjectLiteral, 4);
1455 __ CallRuntime(Runtime::kCreateObjectLiteralShallow, 4);
1458 __ CallStub(&stub);
1478 __ push(eax); // Save result on the stack
1491 __ mov(ecx, Immediate(key->handle()));
1492 __ mov(edx, Operand(esp, 0));
1505 __ push(Operand(esp, 0)); // Duplicate receiver.
1509 __ push(Immediate(Smi::FromInt(NONE))); // PropertyAttributes
1510 __ CallRuntime(Runtime::kSetProperty, 4);
1512 __ Drop(3);
1529 __ push(Operand(esp, 0)); // Duplicate receiver.
1533 __ push(Immediate(Smi::FromInt(NONE)));
1534 __ CallRuntime(Runtime::kDefineOrRedefineAccessorProperty, 5);
1539 __ push(Operand(esp, 0));
1540 __ CallRuntime(Runtime::kToFastProperties, 1);
1564 __ mov(ebx, Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
1565 __ push(FieldOperand(ebx, JSFunction::kLiteralsOffset));
1566 __ push(Immediate(Smi::FromInt(expr->literal_index())));
1567 __ push(Immediate(constant_elements));
1573 __ IncrementCounter(isolate()->counters()->cow_arrays_created_stub(), 1);
1577 __ CallStub(&stub);
1579 __ CallRuntime(Runtime::kCreateArrayLiteral, 3);
1581 __ CallRuntime(Runtime::kCreateArrayLiteralShallow, 3);
1592 __ CallStub(&stub);
1609 __ push(eax);
1618 __ mov(ebx, Operand(esp, 0)); // Copy of array literal.
1619 __ mov(ebx, FieldOperand(ebx, JSObject::kElementsOffset));
1621 __ mov(FieldOperand(ebx, offset), result_register());
1623 __ RecordWriteField(ebx, offset, result_register(), ecx,
1629 __ mov(ebx, Operand(esp, 0)); // Copy of array literal.
1630 __ mov(edi, FieldOperand(ebx, JSObject::kMapOffset));
1631 __ mov(ecx, Immediate(Smi::FromInt(i)));
1632 __ mov(edx, Immediate(Smi::FromInt(expr->literal_index())));
1634 __ CallStub(&stub);
1677 __ push(result_register());
1686 __ mov(edx, Operand(esp, 0));
1687 __ push(eax);
1718 __ push(eax); // Left operand goes on the stack.
1766 __ mov(ecx, Immediate(key->handle()));
1787 __ pop(edx);
1788 __ mov(ecx, eax);
1789 __ or_(eax, edx);
1793 __ bind(&stub_call);
1794 __ mov(eax, ecx);
1798 __ jmp(&done, Label::kNear);
1801 __ bind(&smi_case);
1802 __ mov(eax, edx); // Copy left operand in case of a stub call.
1806 __ SmiUntag(eax);
1807 __ SmiUntag(ecx);
1808 __ sar_cl(eax); // No checks of result necessary
1809 __ SmiTag(eax);
1813 __ SmiUntag(eax);
1814 __ SmiUntag(ecx);
1815 __ shl_cl(eax);
1817 __ cmp(eax, 0xc0000000);
1818 __ j(positive, &result_ok);
1819 __ SmiTag(ecx);
1820 __ jmp(&stub_call);
1821 __ bind(&result_ok);
1822 __ SmiTag(eax);
1827 __ SmiUntag(eax);
1828 __ SmiUntag(ecx);
1829 __ shr_cl(eax);
1830 __ test(eax, Immediate(0xc0000000));
1831 __ j(zero, &result_ok);
1832 __ SmiTag(ecx);
1833 __ jmp(&stub_call);
1834 __ bind(&result_ok);
1835 __ SmiTag(eax);
1839 __ add(eax, ecx);
1840 __ j(overflow, &stub_call);
1843 __ sub(eax, ecx);
1844 __ j(overflow, &stub_call);
1847 __ SmiUntag(eax);
1848 __ imul(eax, ecx);
1849 __ j(overflow, &stub_call);
1850 __ test(eax, eax);
1851 __ j(not_zero, &done, Label::kNear);
1852 __ mov(ebx, edx);
1853 __ or_(ebx, ecx);
1854 __ j(negative, &stub_call);
1858 __ or_(eax, ecx);
1861 __ and_(eax, ecx);
1864 __ xor_(eax, ecx);
1870 __ bind(&done);
1878 __ pop(edx);
1914 __ push(eax); // Preserve value.
1916 __ mov(edx, eax);
1917 __ pop(eax); // Restore value.
1918 __ mov(ecx, prop->key()->AsLiteral()->handle());
1926 __ push(eax); // Preserve value.
1929 __ mov(ecx, eax);
1930 __ pop(edx);
1931 __ pop(eax); // Restore value.
1947 __ mov(ecx, var->name());
1948 __ mov(edx, GlobalObjectOperand());
1959 __ mov(edx, StackOperand(var));
1960 __ cmp(edx, isolate()->factory()->the_hole_value());
1961 __ j(not_equal, &skip);
1962 __ mov(StackOperand(var), eax);
1963 __ bind(&skip);
1971 __ push(eax);
1972 __ push(esi);
1973 __ push(Immediate(var->name()));
1974 __ CallRuntime(Runtime::kInitializeConstContextSlot, 3);
1980 __ push(eax); // Value.
1981 __ push(esi); // Context.
1982 __ push(Immediate(var->name()));
1983 __ push(Immediate(Smi::FromInt(language_mode())));
1984 __ CallRuntime(Runtime::kStoreContextSlot, 4);
1989 __ mov(edx, location);
1990 __ cmp(edx, isolate()->factory()->the_hole_value());
1991 __ j(not_equal, &assign, Label::kNear);
1992 __ push(Immediate(var->name()));
1993 __ CallRuntime(Runtime::kThrowReferenceError, 1);
1994 __ bind(&assign);
1995 __ mov(location, eax);
1997 __ mov(edx, eax);
1999 __ RecordWriteContextSlot(ecx, offset, edx, ebx, kDontSaveFPRegs);
2010 __ mov(edx, location);
2011 __ cmp(edx, isolate()->factory()->the_hole_value());
2012 __ Check(equal, "Let binding re-initialization.");
2015 __ mov(location, eax);
2017 __ mov(edx, eax);
2019 __ RecordWriteContextSlot(ecx, offset, edx, ebx, kDontSaveFPRegs);
2023 __ push(eax); // Value.
2024 __ push(esi); // Context.
2025 __ push(Immediate(var->name()));
2026 __ push(Immediate(Smi::FromInt(language_mode())));
2027 __ CallRuntime(Runtime::kStoreContextSlot, 4);
2044 __ push(result_register());
2045 __ push(Operand(esp, kPointerSize)); // Receiver is now under value.
2046 __ CallRuntime(Runtime::kToSlowProperties, 1);
2047 __ pop(result_register());
2052 __ mov(ecx, prop->key()->AsLiteral()->handle());
2054 __ mov(edx, Operand(esp, 0));
2056 __ pop(edx);
2065 __ push(eax); // Result of assignment, saved even if not needed.
2066 __ push(Operand(esp, kPointerSize)); // Receiver is under value.
2067 __ CallRuntime(Runtime::kToFastProperties, 1);
2068 __ pop(eax);
2069 __ Drop(1);
2083 __ push(result_register());
2085 __ push(Operand(esp, 2 * kPointerSize));
2086 __ CallRuntime(Runtime::kToSlowProperties, 1);
2087 __ pop(result_register());
2090 __ pop(ecx);
2092 __ mov(edx, Operand(esp, 0)); // Leave receiver on the stack for later.
2094 __ pop(edx);
2105 __ pop(edx);
2106 __ push(eax); // Result of assignment, saved even if not needed.
2107 __ push(edx);
2108 __ CallRuntime(Runtime::kToFastProperties, 1);
2109 __ pop(eax);
2128 __ pop(edx);
2139 __ call(code, rmode, ast_id);
2155 __ Set(ecx, Immediate(name));
2164 __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
2176 __ pop(ecx);
2177 __ push(eax);
2178 __ push(ecx);
2192 __ mov(ecx, Operand(esp, (arg_count + 1) * kPointerSize)); // Key.
2196 __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
2221 __ mov(ebx, cell);
2225 __ mov(edi, Operand(esp, (arg_count + 1) * kPointerSize));
2226 __ CallStub(&stub, expr->id());
2230 __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
2238 __ push(Operand(esp, arg_count * kPointerSize));
2240 __ push(Immediate(isolate()->factory()->undefined_value()));
2244 __ push(Operand(ebp, (2 + info_->scope()->num_parameters()) * kPointerSize));
2246 __ push(Immediate(Smi::FromInt(language_mode())));
2249 __ push(Immediate(Smi::FromInt(scope()->start_position())));
2252 __ CallRuntime(Runtime::kResolvePossiblyDirectEval, 5);
2277 __ push(Immediate(isolate()->factory()->undefined_value()));
2285 __ push(Operand(esp, (arg_count + 1) * kPointerSize));
2290 __ mov(Operand(esp, (arg_count + 0) * kPointerSize), edx);
2291 __ mov(Operand(esp, (arg_count + 1) * kPointerSize), eax);
2296 __ mov(edi, Operand(esp, (arg_count + 1) * kPointerSize));
2297 __ CallStub(&stub);
2300 __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
2305 __ push(GlobalObjectOperand());
2316 __ bind(&slow);
2319 __ push(context_register());
2320 __ push(Immediate(proxy->name()));
2321 __ CallRuntime(Runtime::kLoadContextSlot, 2);
2322 __ push(eax); // Function.
2323 __ push(edx); // Receiver.
2329 __ jmp(&call, Label::kNear);
2330 __ bind(&done);
2332 __ push(eax);
2335 __
2336 __ bind(&call);
2362 __ mov(ebx, GlobalObjectOperand());
2363 __ push(FieldOperand(ebx, GlobalObject::kGlobalReceiverOffset));
2398 __ SafeSet(eax, Immediate(arg_count));
2399 __ mov(edi, Operand(esp, arg_count * kPointerSize));
2410 __ mov(ebx, cell);
2416 __ call(stub.GetCode(), RelocInfo::CONSTRUCT_CALL);
2436 __ test(eax, Immediate(kSmiTagMask));
2457 __ test(eax, Immediate(kSmiTagMask | 0x80000000));
2477 __ JumpIfSmi(eax, if_false);
2478 __ cmp(eax, isolate()->factory()->null_value());
2479 __ j(equal, if_true);
2480 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
2482 __ movzx_b(ecx, FieldOperand(ebx, Map::kBitFieldOffset));
2483 __ test(ecx, Immediate(1 << Map::kIsUndetectable));
2484 __ j(not_zero, if_false);
2485 __ movzx_b(ecx, FieldOperand(ebx, Map::kInstanceTypeOffset));
2486 __ cmp(ecx, FIRST_NONCALLABLE_SPEC_OBJECT_TYPE);
2487 __ j(below, if_false);
2488 __ cmp(ecx, LAST_NONCALLABLE_SPEC_OBJECT_TYPE);
2509 __ JumpIfSmi(eax, if_false);
2510 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ebx);
2531 __ JumpIfSmi(eax, if_false);
2532 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
2533 __ movzx_b(ebx, FieldOperand(ebx, Map::kBitFieldOffset));
2534 __ test(ebx, Immediate(1 << Map::kIsUndetectable));
2556 if (FLAG_debug_code) __ AbortIfSmi(eax);
2560 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
2561 __ test_b(FieldOperand(ebx, Map::kBitField2Offset),
2563 __ j(not_zero, if_true);
2566 __ mov(ecx, FieldOperand(eax, JSObject::kPropertiesOffset));
2567 __ mov(ecx, FieldOperand(ecx, HeapObject::kMapOffset));
2568 __ cmp(ecx, FACTORY->hash_table_map());
2569 __ j(equal, if_false);
2574 __ LoadInstanceDescriptors(ebx, ebx);
2575 __ mov(ecx, FieldOperand(ebx, FixedArray::kLengthOffset));
2582 __ lea(ecx, Operand(ebx, ecx, times_2, FixedArray::kHeaderSize));
2584 __ add(ebx,
2590 __ jmp(&entry);
2591 __ bind(&loop);
2592 __ mov(edx, FieldOperand(ebx, 0));
2593 __ cmp(edx, FACTORY->value_of_symbol());
2594 __ j(equal, if_false);
2595 __ add(ebx, Immediate(kPointerSize));
2596 __ bind(&entry);
2597 __ cmp(ebx, ecx);
2598 __ j(not_equal, &loop);
2601 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
2605 __ mov(ecx, FieldOperand(ebx, Map::kPrototypeOffset));
2606 __ JumpIfSmi(ecx, if_false);
2607 __ mov(ecx, FieldOperand(ecx, HeapObject::kMapOffset));
2608 __ mov(edx, Operand(esi, Context::SlotOffset(Context::GLOBAL_INDEX)));
2609 __ mov(edx,
2611 __ cmp(ecx,
2614 __ j(not_equal, if_false);
2617 __ or_(FieldOperand(ebx, Map::kBitField2Offset),
2619 __ jmp(if_true);
2639 __ JumpIfSmi(eax, if_false);
2640 __ CmpObjectType(eax, JS_FUNCTION_TYPE, ebx);
2661 __ JumpIfSmi(eax, if_false);
2662 __ CmpObjectType(eax, JS_ARRAY_TYPE, ebx);
2683 __ JumpIfSmi(eax, if_false);
2684 __ CmpObjectType(eax, JS_REGEXP_TYPE, ebx);
2704 __ mov(eax, Operand(ebp, StandardFrameConstants::kCallerFPOffset));
2708 __ cmp(Operand(eax, StandardFrameConstants::kContextOffset),
2710 __ j(not_equal, &check_frame_marker);
2711 __ mov(eax, Operand(eax, StandardFrameConstants::kCallerFPOffset));
2714 __ bind(&check_frame_marker);
2715 __ cmp(Operand(eax, StandardFrameConstants::kMarkerOffset),
2739 __ pop(ebx);
2740 __ cmp(eax, ebx);
2755 __ mov(edx, eax);
2756 __ SafeSet(eax, Immediate(Smi::FromInt(info_->scope()->num_parameters())));
2758 __ CallStub(&stub);
2768 __ SafeSet(eax, Immediate(Smi::FromInt(info_->scope()->num_parameters())));
2771 __ mov(ebx, Operand(ebp, StandardFrameConstants::kCallerFPOffset));
2772 __ cmp(Operand(ebx, StandardFrameConstants::kContextOffset),
2774 __ j(not_equal, &exit);
2778 __ mov(eax, Operand(ebx, ArgumentsAdaptorFrameConstants::kLengthOffset));
2780 __ bind(&exit);
2781 if (FLAG_debug_code) __ AbortIfNotSmi(eax);
2794 __ JumpIfSmi(eax, &null);
2801 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, eax);
2803 __ j(below, &null);
2806 __ j(equal, &function);
2808 __ CmpInstanceType(eax, LAST_SPEC_OBJECT_TYPE);
2811 __ j(equal, &function);
2816 __ mov(eax, FieldOperand(eax, Map::kConstructorOffset));
2817 __ CmpObjectType(eax, JS_FUNCTION_TYPE, ebx);
2818 __ j(not_equal, &non_function_constructor);
2822 __ mov(eax, FieldOperand(eax, JSFunction::kSharedFunctionInfoOffset));
2823 __ mov(eax, FieldOperand(eax, SharedFunctionInfo::kInstanceClassNameOffset));
2824 __ jmp(&done);
2827 __ bind(&function);
2828 __ mov(eax, isolate()->factory()->function_class_symbol());
2829 __ jmp(&done);
2832 __ bind(&non_function_constructor);
2833 __ mov(eax, isolate()->factory()->Object_symbol());
2834 __ jmp(&done);
2837 __ bind(&null);
2838 __ mov(eax, isolate()->factory()->null_value());
2841 __ bind(&done);
2860 __ CallRuntime(Runtime::kLog, 2);
2863 __ mov(eax, isolate()->factory()->undefined_value());
2874 __ AllocateHeapNumber(edi, ebx, ecx, &slow_allocate_heapnumber);
2875 __ jmp(&heapnumber_allocated);
2877 __ bind(&slow_allocate_heapnumber);
2879 __ CallRuntime(Runtime::kNumberAlloc, 0);
2880 __ mov(edi, eax);
2882 __ bind(&heapnumber_allocated);
2884 __ PrepareCallCFunction(1, ebx);
2885 __ mov(eax, ContextOperand(context_register(), Context::GLOBAL_INDEX));
2886 __ mov(eax, FieldOperand(eax, GlobalObject::kGlobalContextOffset));
2887 __ mov(Operand(esp, 0), eax);
2888 __ CallCFunction(ExternalReference::random_uint32_function(isolate()), 1);
2896 __ mov(ebx, Immediate(0x49800000)); // 1.0 x 2^20 as single.
2897 __ movd(xmm1, ebx);
2898 __ movd(xmm0, eax);
2899 __ cvtss2sd(xmm1, xmm1);
2900 __ xorps(xmm0, xmm1);
2901 __ subsd(xmm0, xmm1);
2902 __ movdbl(FieldOperand(edi, HeapNumber::kValueOffset), xmm0);
2905 __ mov(FieldOperand(edi, HeapNumber::kExponentOffset),
2907 __ mov(FieldOperand(edi, HeapNumber::kMantissaOffset), eax);
2908 __ fld_d(FieldOperand(edi, HeapNumber::kValueOffset));
2909 __ mov(FieldOperand(edi, HeapNumber::kMantissaOffset), Immediate(0));
2910 __ fld_d(FieldOperand(edi, HeapNumber::kValueOffset));
2911 __ fsubp(1);
2912 __ fstp_d(FieldOperand(edi, HeapNumber::kValueOffset));
2914 __ mov(eax, edi);
2927 __ CallStub(&stub);
2941 __ CallStub(&stub);
2954 __ JumpIfSmi(eax, &done, Label::kNear);
2956 __ CmpObjectType(eax, JS_VALUE_TYPE, ebx);
2957 __ j(not_equal, &done, Label::kNear);
2958 __ mov(eax, FieldOperand(eax, JSValue::kValueOffset));
2960 __ bind(&done);
2979 __ AbortIfSmi(object);
2980 __ CmpObjectType(object, JS_DATE_TYPE, scratch);
2981 __ Assert(equal, "Trying to get date field from non-date.");
2985 __ mov(result, FieldOperand(object, JSDate::kValueOffset));
2989 __ mov(scratch, Operand::StaticVariable(stamp));
2990 __ cmp(scratch, FieldOperand(object, JSDate::kCacheStampOffset));
2991 __ j(not_equal, &runtime, Label::kNear);
2992 __ mov(result, FieldOperand(object, JSDate::kValueOffset +
2994 __ jmp(&done);
2996 __ bind(&runtime);
2997 __ PrepareCallCFunction(2, scratch);
2998 __ mov(Operand(esp, 0), object);
2999 __ mov(Operand(esp, 1 * kPointerSize), Immediate(index));
3000 __ CallCFunction(ExternalReference::get_date_field_function(isolate()), 2);
3001 __ bind(&done);
3016 __ CallStub(&stub);
3018 __ CallRuntime(Runtime::kMath_pow, 2);
3030 __ pop(ebx); // eax = value. ebx = object.
3034 __ JumpIfSmi(ebx, &done, Label::kNear);
3037 __ CmpObjectType(ebx, JS_VALUE_TYPE, ecx);
3038 __ j(not_equal, &done, Label::kNear);
3041 __ mov(FieldOperand(ebx, JSValue::kValueOffset), eax);
3045 __ mov(edx, eax);
3046 __ RecordWriteField(ebx, JSValue::kValueOffset, edx, ecx, kDontSaveFPRegs);
3048 __ bind(&done);
3061 __ CallStub(&stub);
3075 __ jmp(&done);
3080 __ bind(&done);
3096 __ pop(object);
3109 __ jmp(&done);
3111 __ bind(&index_out_of_range);
3114 __ Set(result, Immediate(isolate()->factory()->nan_value()));
3115 __ jmp(&done);
3117 __ bind(&need_conversion);
3120 __ Set(result, Immediate(isolate()->factory()->undefined_value()));
3121 __ jmp(&done);
3126 __ bind(&done);
3143 __ pop(object);
3157 __ jmp(&done);
3159 __ bind(&index_out_of_range);
3162 __ Set(result, Immediate(isolate()->factory()->empty_string()));
3163 __ jmp(&done);
3165 __ bind(&need_conversion);
3168 __ Set(result, Immediate(Smi::FromInt(0)));
3169 __ jmp(&done);
3174 __ bind(&done);
3187 __ CallStub(&stub);
3200 __ CallStub(&stub);
3212 __ CallStub(&stub);
3224 __ CallStub(&stub);
3236 __ CallStub(&stub);
3248 __ CallStub(&stub);
3258 __ CallRuntime(Runtime::kMath_sqrt, 1);
3275 __ CmpObjectType(eax, JS_FUNCTION_PROXY_TYPE, ebx);
3276 __ j(equal, &proxy);
3279 __ mov(edi, result_register());
3281 __ InvokeFunction(edi, count, CALL_FUNCTION,
3283 __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
3284 __ jmp(&done);
3286 __ bind(&proxy);
3287 __ push(eax);
3288 __ CallRuntime(Runtime::kCall, args->length());
3289 __ bind(&done);
3303 __ CallStub(&stub);
3318 __ Abort("Attempt to use undefined cache.");
3319 __ mov(eax, isolate()->factory()->undefined_value());
3329 __ mov(cache, ContextOperand(esi, Context::GLOBAL_INDEX));
3330 __ mov(cache,
3332 __ mov(cache, ContextOperand(cache, Context::JSFUNCTION_RESULT_CACHES_INDEX));
3333 __ mov(cache,
3339 __ mov(tmp, FieldOperand(cache, JSFunctionResultCache::kFingerOffset));
3340 __ cmp(key, CodeGenerator::FixedArrayElementOperand(cache, tmp));
3341 __ j(not_equal, ¬_found);
3343 __
3344 __ jmp(&done);
3346 __ bind(¬_found);
3348 __ push(cache);
3349 __ push(key);
3350 __ CallRuntime(Runtime::kGetFromCache, 2);
3352 __ bind(&done);
3367 __ pop(left);
3370 __ cmp(left, right);
3371 __ j(equal, &ok);
3373 __ mov(tmp, left);
3374 __ and_(tmp, right);
3375 __ JumpIfSmi(tmp, &fail);
3376 __ mov(tmp, FieldOperand(left, HeapObject::kMapOffset));
3377 __ CmpInstanceType(tmp, JS_REGEXP_TYPE);
3378 __ j(not_equal, &fail);
3379 __ cmp(tmp, FieldOperand(right, HeapObject::kMapOffset));
3380 __ j(not_equal, &fail);
3381 __ mov(tmp, FieldOperand(left, JSRegExp::kDataOffset));
3382 __ cmp(tmp, FieldOperand(right, JSRegExp::kDataOffset));
3383 __ j(equal, &ok);
3384 __ bind(&fail);
3385 __ mov(eax, Immediate(isolate()->factory()->false_value()));
3386 __ jmp(&done);
3387 __ bind(&ok);
3388 __ mov(eax, Immediate(isolate()->factory()->true_value()));
3389 __ bind(&done);
3402 __ AbortIfNotString(eax);
3412 __ test(FieldOperand(eax, String::kHashFieldOffset),
3427 __ AbortIfNotString(eax);
3430 __ mov(eax, FieldOperand(eax, String::kHashFieldOffset));
3431 __ IndexFromHash(eax, eax);
3467 __ sub(esp, Immediate(2 * kPointerSize));
3468 __ cld();
3470 __ JumpIfSmi(array, &bailout);
3471 __ CmpObjectType(array, JS_ARRAY_TYPE, scratch);
3472 __ j(not_equal, &bailout);
3475 __ CheckFastElements(scratch, &bailout);
3478 __ mov(array_length, FieldOperand(array, JSArray::kLengthOffset));
3479 __ SmiUntag(array_length);
3480 __ j(not_zero, &non_trivial_array);
3481 __ mov(result_operand, isolate()->factory()->empty_string());
3482 __ jmp(&done);
3485 __ bind(&non_trivial_array);
3486 __ mov(array_length_operand, array_length);
3491 __ mov(elements, FieldOperand(array, JSArray::kElementsOffset));
3497 __ Set(index, Immediate(0));
3498 __ Set(string_length, Immediate(0));
3503 __ cmp(index, array_length);
3504 __ Assert(less, "No empty arrays here in EmitFastAsciiArrayJoin");
3506 __ bind(&loop);
3507 __ mov(string, FieldOperand(elements,
3511 __ JumpIfSmi(string, &bailout);
3512 __ mov(scratch, FieldOperand(string, HeapObject::kMapOffset));
3513 __ movzx_b(scratch, FieldOperand(scratch, Map::kInstanceTypeOffset));
3514 __ and_(scratch, Immediate(
3516 __ cmp(scratch, kStringTag | kAsciiStringTag | kSeqStringTag);
3517 __ j(not_equal, &bailout);
3518 __ add(string_length,
3520 __ j(overflow, &bailout);
3521 __ add(index, Immediate(1));
3522 __ cmp(index, array_length);
3523 __ j(less, &loop);
3526 __ cmp(array_length, 1);
3527 __ j(not_equal, ¬_size_one_array);
3528 __ mov(scratch, FieldOperand(elements, FixedArray::kHeaderSize));
3529 __ mov(result_operand, scratch);
3530 __ jmp(&done);
3532 __ bind(¬_size_one_array);
3543 __ mov(string, separator_operand);
3544 __ JumpIfSmi(string, &bailout);
3545 __ mov(scratch, FieldOperand(string, HeapObject::kMapOffset));
3546 __ movzx_b(scratch, FieldOperand(scratch, Map::kInstanceTypeOffset));
3547 __ and_(scratch, Immediate(
3549 __ cmp(scratch, ASCII_STRING_TYPE);
3550 __ j(not_equal, &bailout);
3554 __ mov(scratch, separator_operand);
3555 __ mov(scratch, FieldOperand(scratch, SeqAsciiString::kLengthOffset));
3556 __ sub(string_length, scratch); // May be negative, temporarily.
3557 __ imul(scratch, array_length_operand);
3558 __ j(overflow, &bailout);
3559 __ add(string_length, scratch);
3560 __ j(overflow, &bailout);
3562 __ shr(string_length, 1);
3566 __ AllocateAsciiString(result_pos, string_length, scratch,
3568 __ mov(result_operand, result_pos);
3569 __ lea(result_pos, FieldOperand(result_pos, SeqAsciiString::kHeaderSize));
3572 __ mov(string, separator_operand);
3573 __ cmp(FieldOperand(string, SeqAsciiString::kLengthOffset),
3575 __ j(equal, &one_char_separator);
3576 __ j(greater, &long_separator);
3580 __ mov(index, Immediate(0));
3581 __ jmp(&loop_1_condition);
3583 __ bind(&loop_1);
3591 __ mov(string, FieldOperand(elements, index,
3594 __ mov(string_length,
3596 __ shr(string_length, 1);
3597 __ lea(string,
3599 __ CopyBytes(string, result_pos, string_length, scratch);
3600 __ add(index, Immediate(1));
3601 __ bind(&loop_1_condition);
3602 __ cmp(index, array_length_operand);
3603 __ j(less, &loop_1); // End while (index < length).
3604 __ jmp(&done);
3609 __ bind(&one_char_separator);
3611 __ mov_b(scratch, FieldOperand(string, SeqAsciiString::kHeaderSize));
3612 __ mov_b(separator_operand, scratch);
3614 __ Set(index, Immediate(0));
3617 __ jmp(&loop_2_entry);
3619 __ bind(&loop_2);
3626 __ mov_b(scratch, separator_operand);
3627 __ mov_b(Operand(result_pos, 0), scratch);
3628 __ inc(result_pos);
3630 __ bind(&loop_2_entry);
3632 __ mov(string, FieldOperand(elements, index,
3635 __ mov(string_length,
3637 __ shr(string_length, 1);
3638 __ lea(string,
3640 __ CopyBytes(string, result_pos, string_length, scratch);
3641 __ add(index, Immediate(1));
3643 __ cmp(index, array_length_operand);
3644 __ j(less, &loop_2); // End while (index < length).
3645 __ jmp(&done);
3649 __ bind(&long_separator);
3651 __ Set(index, Immediate(0));
3654 __ jmp(&loop_3_entry);
3656 __ bind(&loop_3);
3663 __ mov(string, separator_operand);
3664 __ mov(string_length,
3666 __ shr(string_length, 1);
3667 __ lea(string,
3669 __ CopyBytes(string, result_pos, string_length, scratch);
3671 __ bind(&loop_3_entry);
3673 __ mov(string, FieldOperand(elements, index,
3676 __ mov(string_length,
3678 __ shr(string_length, 1);
3679 __ lea(string,
3681 __ CopyBytes(string, result_pos, string_length, scratch);
3682 __ add(index, Immediate(1));
3684 __ cmp(index, array_length_operand);
3685 __ j(less, &loop_3); // End while (index < length).
3686 __ jmp(&done);
3689 __ bind(&bailout);
3690 __ mov(result_operand, isolate()->factory()->undefined_value());
3691 __ bind(&done);
3692 __ mov(eax, result_operand);
3694 __ add(esp, Immediate(3 * kPointerSize));
3696 __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
3714 __ mov(eax, GlobalObjectOperand());
3715 __ push(FieldOperand(eax, GlobalObject::kBuiltinsOffset));
3726 __ Set(ecx, Immediate(expr->name()));
3732 __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
3735 __ CallRuntime(expr->function(), arg_count);
3753 __ push(Immediate(Smi::FromInt(strict_mode_flag)));
3754 __ InvokeBuiltin(Builtins::DELETE, CALL_FUNCTION);
3762 __ push(GlobalObjectOperand());
3763 __ push(Immediate(var->name()));
3764 __ push(Immediate(Smi::FromInt(kNonStrictMode)));
3765 __ InvokeBuiltin(Builtins::DELETE, CALL_FUNCTION);
3775 __ push(context_register());
3776 __ push(Immediate(var->name()));
3777 __ CallRuntime(Runtime::kDeleteContextSlot, 2);
3821 __ bind(&materialize_true);
3824 __ mov(eax, isolate()->factory()->true_value());
3826 __ Push(isolate()->factory()->true_value());
3828 __ jmp(&done, Label::kNear);
3829 __ bind(&materialize_false);
3832 __ mov(eax, isolate()->factory()->false_value());
3834 __ Push(isolate()->factory()->false_value());
3836 __ bind(&done);
3846 __ CallRuntime(Runtime::kTypeof, 1);
3855 __ JumpIfSmi(result_register(), &no_conversion);
3857 __ CallStub(&convert_stub);
3858 __ bind(&no_conversion);
3924 __ push(Immediate(Smi::FromInt(0)));
3929 __ push(eax);
3934 __ mov(edx, Operand(esp, 0));
3935 __ push(eax);
3951 __ JumpIfSmi(eax, &no_conversion, Label::kNear);
3954 __ CallStub(&convert_stub);
3955 __ bind(&no_conversion);
3965 __ push(eax);
3968 __ mov(Operand(esp, kPointerSize), eax);
3971 __ mov(Operand(esp, 2 * kPointerSize), eax);
3983 __ add(eax, Immediate(Smi::FromInt(1)));
3985 __ sub(eax, Immediate(Smi::FromInt(1)));
3987 __ j(overflow, &stub_call, Label::kNear);
3992 __ bind(&stub_call);
3995 __ sub(eax, Immediate(Smi::FromInt(1)));
3997 __ add(eax, Immediate(Smi::FromInt(1)));
4005 __ mov(edx, eax);
4006 __ mov(eax, Immediate(Smi::FromInt(1)));
4010 __ bind(&done);
4037 __ mov(ecx, prop->key()->AsLiteral()->handle());
4038 __ pop(edx);
4054 __ pop(ecx);
4055 __ pop(edx);
4082 __ mov(eax, GlobalObjectOperand());
4083 __ mov(ecx, Immediate(proxy->name()));
4097 __ bind(&slow);
4098 __ push(esi);
4099 __ push(Immediate(proxy->name()));
4100 __ CallRuntime(Runtime::kLoadContextSlotNoReferenceError, 2);
4102 __ bind(&done);
4128 __ JumpIfSmi(eax, if_true);
4129 __ cmp(FieldOperand(eax, HeapObject::kMapOffset),
4133 __ JumpIfSmi(eax, if_false);
4134 __ CmpObjectType(eax, FIRST_NONSTRING_TYPE, edx);
4135 __ j(above_equal, if_false);
4137 __ test_b(FieldOperand(edx, Map::kBitFieldOffset),
4141 __ cmp(eax, isolate()->factory()->true_value());
4142 __ j(equal, if_true);
4143 __ cmp(eax, isolate()->factory()->false_value());
4147 __ cmp(eax, isolate()->factory()->null_value());
4150 __ cmp(eax, isolate()->factory()->undefined_value());
4151 __ j(equal, if_true);
4152 __ JumpIfSmi(eax, if_false);
4154 __ mov(edx, FieldOperand(eax, HeapObject::kMapOffset));
4155 __ movzx_b(ecx, FieldOperand(edx, Map::kBitFieldOffset));
4156 __ test(ecx, Immediate(1 << Map::kIsUndetectable));
4159 __ JumpIfSmi(eax, if_false);
4161 __ CmpObjectType(eax, JS_FUNCTION_TYPE, edx);
4162 __ j(equal, if_true);
4163 __ CmpInstanceType(edx, JS_FUNCTION_PROXY_TYPE);
4166 __ JumpIfSmi(eax, if_false);
4168 __ cmp(eax, isolate()->factory()->null_value());
4169 __ j(equal, if_true);
4171 __ CmpObjectType(eax, FIRST_NONCALLABLE_SPEC_OBJECT_TYPE, edx);
4172 __ j(below, if_false);
4173 __ CmpInstanceType(edx, LAST_NONCALLABLE_SPEC_OBJECT_TYPE);
4174 __ j(above, if_false);
4176 __ test_b(FieldOperand(edx, Map::kBitFieldOffset),
4180 if (if_false != fall_through) __ jmp(if_false);
4208 __ InvokeBuiltin(Builtins::IN, CALL_FUNCTION);
4210 __ cmp(eax, isolate()->factory()->true_value());
4217 __ CallStub(&stub);
4219 __ test(eax, eax);
4250 __ pop(edx);
4256 __ mov(ecx, edx);
4257 __ or_(ecx, eax);
4259 __ cmp(edx, eax);
4261 __ bind(&slow_case);
4271 __ test(eax, eax);
4297 __ cmp(eax, nil_value);
4304 __ j(equal, if_true);
4305 __ cmp(eax, other_nil_value);
4306 __ j(equal, if_true);
4307 __ JumpIfSmi(eax, if_false);
4309 __ mov(edx, FieldOperand(eax, HeapObject::kMapOffset));
4310 __ movzx_b(edx, FieldOperand(edx, Map::kBitFieldOffset));
4311 __ test(edx, Immediate(1 << Map::kIsUndetectable));
4319 __ mov(eax, Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
4336 __ mov(Operand(ebp, frame_offset), value);
4341 __ mov(dst, ContextOperand(esi, context_index));
4352 __ push(Immediate(Smi::FromInt(0)));
4357 __ push(ContextOperand(esi, Context::CLOSURE_INDEX));
4360 __ push(Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
4371 __ pop(edx);
4372 __ sub(edx, Immediate(masm_->CodeObject()));
4375 __ SmiTag(edx);
4376 __ push(edx);
4378 __ push(result_register());
4384 __ pop(result_register());
4386 __ pop(edx);
4387 __ SmiUntag(edx);
4388 __ add(edx, Immediate(masm_->CodeObject()));
4389 __ jmp(edx);
4393 #undef __
4395 #define __ ACCESS_MASM(masm())
4406 __ Drop(*stack_depth); // Down to the handler block.
4409 __ mov(esi, Operand(esp, StackHandlerConstants::kContextOffset));
4410 __ mov(Operand(ebp, StandardFrameConstants::kContextOffset), esi);
4412 __ PopTryHandler();
4413 __ call(finally_entry_);
4421 #undef __
