| Index: src/ia32/stub-cache-ia32.cc
|
| ===================================================================
|
| --- src/ia32/stub-cache-ia32.cc (revision 9808)
|
| +++ src/ia32/stub-cache-ia32.cc (working copy)
|
| @@ -107,12 +107,12 @@
|
| // must always call a backup property check that is complete.
|
| // This function is safe to call if the receiver has fast properties.
|
| // Name must be a symbol and receiver must be a heap object.
|
| -static MaybeObject* GenerateDictionaryNegativeLookup(MacroAssembler* masm,
|
| - Label* miss_label,
|
| - Register receiver,
|
| - String* name,
|
| - Register r0,
|
| - Register r1) {
|
| +static void GenerateDictionaryNegativeLookup(MacroAssembler* masm,
|
| + Label* miss_label,
|
| + Register receiver,
|
| + Handle<String> name,
|
| + Register r0,
|
| + Register r1) {
|
| ASSERT(name->IsSymbol());
|
| Counters* counters = masm->isolate()->counters();
|
| __ IncrementCounter(counters->negative_lookups(), 1);
|
| @@ -142,13 +142,61 @@
|
| __ j(not_equal, miss_label);
|
|
|
| Label done;
|
| + StringDictionaryLookupStub::GenerateNegativeLookup(masm,
|
| + miss_label,
|
| + &done,
|
| + properties,
|
| + name,
|
| + r1);
|
| + __ bind(&done);
|
| + __ DecrementCounter(counters->negative_lookups_miss(), 1);
|
| +}
|
| +
|
| +
|
| +// TODO(kmillikin): Eliminate this function when the stub cache is fully
|
| +// handlified.
|
| +static MaybeObject* TryGenerateDictionaryNegativeLookup(MacroAssembler* masm,
|
| + Label* miss_label,
|
| + Register receiver,
|
| + String* name,
|
| + Register r0,
|
| + Register r1) {
|
| + ASSERT(name->IsSymbol());
|
| + Counters* counters = masm->isolate()->counters();
|
| + __ IncrementCounter(counters->negative_lookups(), 1);
|
| + __ IncrementCounter(counters->negative_lookups_miss(), 1);
|
| +
|
| + __ mov(r0, FieldOperand(receiver, HeapObject::kMapOffset));
|
| +
|
| + const int kInterceptorOrAccessCheckNeededMask =
|
| + (1 << Map::kHasNamedInterceptor) | (1 << Map::kIsAccessCheckNeeded);
|
| +
|
| + // Bail out if the receiver has a named interceptor or requires access checks.
|
| + __ test_b(FieldOperand(r0, Map::kBitFieldOffset),
|
| + kInterceptorOrAccessCheckNeededMask);
|
| + __ j(not_zero, miss_label);
|
| +
|
| + // Check that receiver is a JSObject.
|
| + __ CmpInstanceType(r0, FIRST_SPEC_OBJECT_TYPE);
|
| + __ j(below, miss_label);
|
| +
|
| + // Load properties array.
|
| + Register properties = r0;
|
| + __ mov(properties, FieldOperand(receiver, JSObject::kPropertiesOffset));
|
| +
|
| + // Check that the properties array is a dictionary.
|
| + __ cmp(FieldOperand(properties, HeapObject::kMapOffset),
|
| + Immediate(masm->isolate()->factory()->hash_table_map()));
|
| + __ j(not_equal, miss_label);
|
| +
|
| + Label done;
|
| MaybeObject* result =
|
| - StringDictionaryLookupStub::GenerateNegativeLookup(masm,
|
| - miss_label,
|
| - &done,
|
| - properties,
|
| - name,
|
| - r1);
|
| + StringDictionaryLookupStub::TryGenerateNegativeLookup(masm,
|
| + miss_label,
|
| + &done,
|
| + properties,
|
| + name,
|
| + r1);
|
| if (result->IsFailure()) return result;
|
|
|
| __ bind(&done);
|
| @@ -165,25 +213,23 @@
|
| Register scratch,
|
| Register extra,
|
| Register extra2) {
|
| - Isolate* isolate = Isolate::Current();
|
| Label miss;
|
| - USE(extra2); // The register extra2 is not used on the ia32 platform.
|
|
|
| - // Make sure that code is valid. The shifting code relies on the
|
| - // entry size being 8.
|
| + // Assert that code is valid. The shifting code relies on the entry size
|
| + // being 8.
|
| ASSERT(sizeof(Entry) == 8);
|
|
|
| - // Make sure the flags does not name a specific type.
|
| + // Assert the flags do not name a specific type.
|
| ASSERT(Code::ExtractTypeFromFlags(flags) == 0);
|
|
|
| - // Make sure that there are no register conflicts.
|
| + // Assert that there are no register conflicts.
|
| ASSERT(!scratch.is(receiver));
|
| ASSERT(!scratch.is(name));
|
| ASSERT(!extra.is(receiver));
|
| ASSERT(!extra.is(name));
|
| ASSERT(!extra.is(scratch));
|
|
|
| - // Check scratch and extra registers are valid, and extra2 is unused.
|
| + // Assert scratch and extra registers are valid, and extra2 is unused.
|
| ASSERT(!scratch.is(no_reg));
|
| ASSERT(extra2.is(no_reg));
|
|
|
| @@ -197,7 +243,7 @@
|
| __ and_(scratch, (kPrimaryTableSize - 1) << kHeapObjectTagSize);
|
|
|
| // Probe the primary table.
|
| - ProbeTable(isolate, masm, flags, kPrimary, name, scratch, extra);
|
| + ProbeTable(isolate(), masm, flags, kPrimary, name, scratch, extra);
|
|
|
| // Primary miss: Compute hash for secondary probe.
|
| __ mov(scratch, FieldOperand(name, String::kHashFieldOffset));
|
| @@ -209,7 +255,7 @@
|
| __ and_(scratch, (kSecondaryTableSize - 1) << kHeapObjectTagSize);
|
|
|
| // Probe the secondary table.
|
| - ProbeTable(isolate, masm, flags, kSecondary, name, scratch, extra);
|
| + ProbeTable(isolate(), masm, flags, kSecondary, name, scratch, extra);
|
|
|
| // Cache miss: Fall-through and let caller handle the miss by
|
| // entering the runtime system.
|
| @@ -327,8 +373,10 @@
|
| // are loaded directly otherwise the property is loaded from the properties
|
| // fixed array.
|
| void StubCompiler::GenerateFastPropertyLoad(MacroAssembler* masm,
|
| - Register dst, Register src,
|
| - JSObject* holder, int index) {
|
| + Register dst,
|
| + Register src,
|
| + Handle<JSObject> holder,
|
| + int index) {
|
| // Adjust for the number of properties stored in the holder.
|
| index -= holder->map()->inobject_properties();
|
| if (index < 0) {
|
| @@ -486,11 +534,11 @@
|
| CallInterceptorCompiler(StubCompiler* stub_compiler,
|
| const ParameterCount& arguments,
|
| Register name,
|
| - Code::ExtraICState extra_ic_state)
|
| + Code::ExtraICState extra_state)
|
| : stub_compiler_(stub_compiler),
|
| arguments_(arguments),
|
| name_(name),
|
| - extra_ic_state_(extra_ic_state) {}
|
| + extra_state_(extra_state) {}
|
|
|
| MaybeObject* Compile(MacroAssembler* masm,
|
| JSObject* object,
|
| @@ -614,7 +662,7 @@
|
| GenerateFastApiCall(masm, optimization, arguments_.immediate());
|
| if (result->IsFailure()) return result;
|
| } else {
|
| - CallKind call_kind = CallICBase::Contextual::decode(extra_ic_state_)
|
| + CallKind call_kind = CallICBase::Contextual::decode(extra_state_)
|
| ? CALL_AS_FUNCTION
|
| : CALL_AS_METHOD;
|
| __ InvokeFunction(optimization.constant_function(), arguments_,
|
| @@ -700,21 +748,16 @@
|
| StubCompiler* stub_compiler_;
|
| const ParameterCount& arguments_;
|
| Register name_;
|
| - Code::ExtraICState extra_ic_state_;
|
| + Code::ExtraICState extra_state_;
|
| };
|
|
|
|
|
| void StubCompiler::GenerateLoadMiss(MacroAssembler* masm, Code::Kind kind) {
|
| ASSERT(kind == Code::LOAD_IC || kind == Code::KEYED_LOAD_IC);
|
| - Code* code = NULL;
|
| - if (kind == Code::LOAD_IC) {
|
| - code = masm->isolate()->builtins()->builtin(Builtins::kLoadIC_Miss);
|
| - } else {
|
| - code = masm->isolate()->builtins()->builtin(Builtins::kKeyedLoadIC_Miss);
|
| - }
|
| -
|
| - Handle<Code> ic(code);
|
| - __ jmp(ic, RelocInfo::CODE_TARGET);
|
| + Handle<Code> code = (kind == Code::LOAD_IC)
|
| + ? masm->isolate()->builtins()->LoadIC_Miss()
|
| + : masm->isolate()->builtins()->KeyedLoadIC_Miss();
|
| + __ jmp(code, RelocInfo::CODE_TARGET);
|
| }
|
|
|
|
|
| @@ -729,9 +772,9 @@
|
| // Both name_reg and receiver_reg are preserved on jumps to miss_label,
|
| // but may be destroyed if store is successful.
|
| void StubCompiler::GenerateStoreField(MacroAssembler* masm,
|
| - JSObject* object,
|
| + Handle<JSObject> object,
|
| int index,
|
| - Map* transition,
|
| + Handle<Map> transition,
|
| Register receiver_reg,
|
| Register name_reg,
|
| Register scratch,
|
| @@ -754,12 +797,12 @@
|
| ASSERT(object->IsJSGlobalProxy() || !object->IsAccessCheckNeeded());
|
|
|
| // Perform map transition for the receiver if necessary.
|
| - if ((transition != NULL) && (object->map()->unused_property_fields() == 0)) {
|
| + if (!transition.is_null() && (object->map()->unused_property_fields() == 0)) {
|
| // The properties must be extended before we can store the value.
|
| // We jump to a runtime call that extends the properties array.
|
| __ pop(scratch); // Return address.
|
| __ push(receiver_reg);
|
| - __ push(Immediate(Handle<Map>(transition)));
|
| + __ push(Immediate(transition));
|
| __ push(eax);
|
| __ push(scratch);
|
| __ TailCallExternalReference(
|
| @@ -770,11 +813,11 @@
|
| return;
|
| }
|
|
|
| - if (transition != NULL) {
|
| + if (!transition.is_null()) {
|
| // Update the map of the object; no write barrier updating is
|
| // needed because the map is never in new space.
|
| __ mov(FieldOperand(receiver_reg, HeapObject::kMapOffset),
|
| - Immediate(Handle<Map>(transition)));
|
| + Immediate(transition));
|
| }
|
|
|
| // Adjust for the number of properties stored in the object. Even in the
|
| @@ -820,7 +863,29 @@
|
| // Generate code to check that a global property cell is empty. Create
|
| // the property cell at compilation time if no cell exists for the
|
| // property.
|
| -MUST_USE_RESULT static MaybeObject* GenerateCheckPropertyCell(
|
| +static void GenerateCheckPropertyCell(MacroAssembler* masm,
|
| + Handle<GlobalObject> global,
|
| + Handle<String> name,
|
| + Register scratch,
|
| + Label* miss) {
|
| + Handle<JSGlobalPropertyCell> cell =
|
| + GlobalObject::EnsurePropertyCell(global, name);
|
| + ASSERT(cell->value()->IsTheHole());
|
| + Handle<Oddball> the_hole = masm->isolate()->factory()->the_hole_value();
|
| + if (Serializer::enabled()) {
|
| + __ mov(scratch, Immediate(cell));
|
| + __ cmp(FieldOperand(scratch, JSGlobalPropertyCell::kValueOffset),
|
| + Immediate(the_hole));
|
| + } else {
|
| + __ cmp(Operand::Cell(cell), Immediate(the_hole));
|
| + }
|
| + __ j(not_equal, miss);
|
| +}
|
| +
|
| +
|
| +// TODO(kmillikin): Eliminate this function when the stub cache is fully
|
| +// handlified.
|
| +MUST_USE_RESULT static MaybeObject* TryGenerateCheckPropertyCell(
|
| MacroAssembler* masm,
|
| GlobalObject* global,
|
| String* name,
|
| @@ -847,7 +912,29 @@
|
|
|
| // Calls GenerateCheckPropertyCell for each global object in the prototype chain
|
| // from object to (but not including) holder.
|
| -MUST_USE_RESULT static MaybeObject* GenerateCheckPropertyCells(
|
| +static void GenerateCheckPropertyCells(MacroAssembler* masm,
|
| + Handle<JSObject> object,
|
| + Handle<JSObject> holder,
|
| + Handle<String> name,
|
| + Register scratch,
|
| + Label* miss) {
|
| + Handle<JSObject> current = object;
|
| + while (!current.is_identical_to(holder)) {
|
| + if (current->IsGlobalObject()) {
|
| + GenerateCheckPropertyCell(masm,
|
| + Handle<GlobalObject>::cast(current),
|
| + name,
|
| + scratch,
|
| + miss);
|
| + }
|
| + current = Handle<JSObject>(JSObject::cast(current->GetPrototype()));
|
| + }
|
| +}
|
| +
|
| +
|
| +// TODO(kmillikin): Eliminate this function when the stub cache is fully
|
| +// handlified.
|
| +MUST_USE_RESULT static MaybeObject* TryGenerateCheckPropertyCells(
|
| MacroAssembler* masm,
|
| JSObject* object,
|
| JSObject* holder,
|
| @@ -858,7 +945,7 @@
|
| while (current != holder) {
|
| if (current->IsGlobalObject()) {
|
| // Returns a cell or a failure.
|
| - MaybeObject* result = GenerateCheckPropertyCell(
|
| + MaybeObject* result = TryGenerateCheckPropertyCell(
|
| masm,
|
| GlobalObject::cast(current),
|
| name,
|
| @@ -877,6 +964,120 @@
|
| #define __ ACCESS_MASM(masm())
|
|
|
|
|
| +Register StubCompiler::CheckPrototypes(Handle<JSObject> object,
|
| + Register object_reg,
|
| + Handle<JSObject> holder,
|
| + Register holder_reg,
|
| + Register scratch1,
|
| + Register scratch2,
|
| + Handle<String> name,
|
| + int save_at_depth,
|
| + Label* miss) {
|
| + // Make sure there's no overlap between holder and object registers.
|
| + ASSERT(!scratch1.is(object_reg) && !scratch1.is(holder_reg));
|
| + ASSERT(!scratch2.is(object_reg) && !scratch2.is(holder_reg)
|
| + && !scratch2.is(scratch1));
|
| +
|
| + // Keep track of the current object in register reg.
|
| + Register reg = object_reg;
|
| + Handle<JSObject> current = object;
|
| + int depth = 0;
|
| +
|
| + if (save_at_depth == depth) {
|
| + __ mov(Operand(esp, kPointerSize), reg);
|
| + }
|
| +
|
| + // Traverse the prototype chain and check the maps in the prototype chain for
|
| + // fast and global objects or do negative lookup for normal objects.
|
| + while (!current.is_identical_to(holder)) {
|
| + ++depth;
|
| +
|
| + // Only global objects and objects that do not require access
|
| + // checks are allowed in stubs.
|
| + ASSERT(current->IsJSGlobalProxy() || !current->IsAccessCheckNeeded());
|
| +
|
| + Handle<JSObject> prototype(JSObject::cast(current->GetPrototype()));
|
| + if (!current->HasFastProperties() &&
|
| + !current->IsJSGlobalObject() &&
|
| + !current->IsJSGlobalProxy()) {
|
| + if (!name->IsSymbol()) {
|
| + name = factory()->LookupSymbol(name);
|
| + }
|
| + ASSERT(current->property_dictionary()->FindEntry(*name) ==
|
| + StringDictionary::kNotFound);
|
| +
|
| + GenerateDictionaryNegativeLookup(masm(), miss, reg, name,
|
| + scratch1, scratch2);
|
| +
|
| + __ mov(scratch1, FieldOperand(reg, HeapObject::kMapOffset));
|
| + reg = holder_reg; // From now on the object will be in holder_reg.
|
| + __ mov(reg, FieldOperand(scratch1, Map::kPrototypeOffset));
|
| + } else {
|
| + bool in_new_space = heap()->InNewSpace(*prototype);
|
| + Handle<Map> current_map(current->map());
|
| + if (in_new_space) {
|
| + // Save the map in scratch1 for later.
|
| + __ mov(scratch1, FieldOperand(reg, HeapObject::kMapOffset));
|
| + __ cmp(scratch1, Immediate(current_map));
|
| + } else {
|
| + __ cmp(FieldOperand(reg, HeapObject::kMapOffset),
|
| + Immediate(current_map));
|
| + }
|
| + // Branch on the result of the map check.
|
| + __ j(not_equal, miss);
|
| + // Check access rights to the global object. This has to happen after
|
| + // the map check so that we know that the object is actually a global
|
| + // object.
|
| + if (current->IsJSGlobalProxy()) {
|
| + __ CheckAccessGlobalProxy(reg, scratch2, miss);
|
| + }
|
| + reg = holder_reg; // From now on the object will be in holder_reg.
|
| +
|
| + if (in_new_space) {
|
| + // The prototype is in new space; we cannot store a reference to it
|
| + // in the code. Load it from the map.
|
| + __ mov(reg, FieldOperand(scratch1, Map::kPrototypeOffset));
|
| + } else {
|
| + // The prototype is in old space; load it directly.
|
| + __ mov(reg, prototype);
|
| + }
|
| + }
|
| +
|
| + if (save_at_depth == depth) {
|
| + __ mov(Operand(esp, kPointerSize), reg);
|
| + }
|
| +
|
| + // Go to the next object in the prototype chain.
|
| + current = prototype;
|
| + }
|
| + ASSERT(current.is_identical_to(holder));
|
| +
|
| + // Log the check depth.
|
| + LOG(isolate(), IntEvent("check-maps-depth", depth + 1));
|
| +
|
| + // Check the holder map.
|
| + __ cmp(FieldOperand(reg, HeapObject::kMapOffset),
|
| + Immediate(Handle<Map>(holder->map())));
|
| + __ j(not_equal, miss);
|
| +
|
| + // Perform security check for access to the global object.
|
| + ASSERT(holder->IsJSGlobalProxy() || !holder->IsAccessCheckNeeded());
|
| + if (holder->IsJSGlobalProxy()) {
|
| + __ CheckAccessGlobalProxy(reg, scratch1, miss);
|
| + }
|
| +
|
| + // If we've skipped any global objects, it's not enough to verify that
|
| + // their maps haven't changed. We also need to check that the property
|
| + // cell for the property is still empty.
|
| + GenerateCheckPropertyCells(masm(), object, holder, name, scratch1, miss);
|
| +
|
| + // Return the register containing the holder.
|
| + return reg;
|
| +}
|
| +
|
| +
|
| +// TODO(kmillikin): Eliminate this function when the stub cache is fully
|
| +// handlified.
|
| Register StubCompiler::CheckPrototypes(JSObject* object,
|
| Register object_reg,
|
| JSObject* holder,
|
| @@ -926,12 +1127,9 @@
|
| ASSERT(current->property_dictionary()->FindEntry(name) ==
|
| StringDictionary::kNotFound);
|
|
|
| - MaybeObject* negative_lookup = GenerateDictionaryNegativeLookup(masm(),
|
| - miss,
|
| - reg,
|
| - name,
|
| - scratch1,
|
| - scratch2);
|
| + MaybeObject* negative_lookup =
|
| + TryGenerateDictionaryNegativeLookup(masm(), miss, reg, name,
|
| + scratch1, scratch2);
|
| if (negative_lookup->IsFailure()) {
|
| set_failure(Failure::cast(negative_lookup));
|
| return reg;
|
| @@ -998,17 +1196,17 @@
|
| ASSERT(holder->IsJSGlobalProxy() || !holder->IsAccessCheckNeeded());
|
| if (holder->IsJSGlobalProxy()) {
|
| __ CheckAccessGlobalProxy(reg, scratch1, miss);
|
| - };
|
| + }
|
|
|
| // If we've skipped any global objects, it's not enough to verify
|
| // that their maps haven't changed. We also need to check that the
|
| // property cell for the property is still empty.
|
| - MaybeObject* result = GenerateCheckPropertyCells(masm(),
|
| - object,
|
| - holder,
|
| - name,
|
| - scratch1,
|
| - miss);
|
| + MaybeObject* result = TryGenerateCheckPropertyCells(masm(),
|
| + object,
|
| + holder,
|
| + name,
|
| + scratch1,
|
| + miss);
|
| if (result->IsFailure()) set_failure(Failure::cast(result));
|
|
|
| // Return the register containing the holder.
|
| @@ -1016,22 +1214,21 @@
|
| }
|
|
|
|
|
| -void StubCompiler::GenerateLoadField(JSObject* object,
|
| - JSObject* holder,
|
| +void StubCompiler::GenerateLoadField(Handle<JSObject> object,
|
| + Handle<JSObject> holder,
|
| Register receiver,
|
| Register scratch1,
|
| Register scratch2,
|
| Register scratch3,
|
| int index,
|
| - String* name,
|
| + Handle<String> name,
|
| Label* miss) {
|
| // Check that the receiver isn't a smi.
|
| __ JumpIfSmi(receiver, miss);
|
|
|
| // Check the prototype chain.
|
| - Register reg =
|
| - CheckPrototypes(object, receiver, holder,
|
| - scratch1, scratch2, scratch3, name, miss);
|
| + Register reg = CheckPrototypes(
|
| + object, receiver, holder, scratch1, scratch2, scratch3, name, miss);
|
|
|
| // Get the value from the properties.
|
| GenerateFastPropertyLoad(masm(), eax, reg, holder, index);
|
| @@ -1106,24 +1303,24 @@
|
| }
|
|
|
|
|
| -void StubCompiler::GenerateLoadConstant(JSObject* object,
|
| - JSObject* holder,
|
| +void StubCompiler::GenerateLoadConstant(Handle<JSObject> object,
|
| + Handle<JSObject> holder,
|
| Register receiver,
|
| Register scratch1,
|
| Register scratch2,
|
| Register scratch3,
|
| - Object* value,
|
| - String* name,
|
| + Handle<Object> value,
|
| + Handle<String> name,
|
| Label* miss) {
|
| // Check that the receiver isn't a smi.
|
| __ JumpIfSmi(receiver, miss);
|
|
|
| // Check that the maps haven't changed.
|
| - CheckPrototypes(object, receiver, holder,
|
| - scratch1, scratch2, scratch3, name, miss);
|
| + CheckPrototypes(
|
| + object, receiver, holder, scratch1, scratch2, scratch3, name, miss);
|
|
|
| // Return the constant value.
|
| - __ mov(eax, Handle<Object>(value));
|
| + __ mov(eax, value);
|
| __ ret(0);
|
| }
|
|
|
| @@ -1223,7 +1420,8 @@
|
| // We found FIELD property in prototype chain of interceptor's holder.
|
| // Retrieve a field from field's holder.
|
| GenerateFastPropertyLoad(masm(), eax, holder_reg,
|
| - lookup->holder(), lookup->GetFieldIndex());
|
| + Handle<JSObject>(lookup->holder()),
|
| + lookup->GetFieldIndex());
|
| __ ret(0);
|
| } else {
|
| // We found CALLBACKS property in prototype chain of interceptor's
|
| @@ -1270,9 +1468,9 @@
|
| }
|
|
|
|
|
| -void CallStubCompiler::GenerateNameCheck(String* name, Label* miss) {
|
| +void CallStubCompiler::GenerateNameCheck(Handle<String> name, Label* miss) {
|
| if (kind_ == Code::KEYED_CALL_IC) {
|
| - __ cmp(ecx, Immediate(Handle<String>(name)));
|
| + __ cmp(ecx, Immediate(name));
|
| __ j(not_equal, miss);
|
| }
|
| }
|
| @@ -1335,11 +1533,22 @@
|
| }
|
|
|
|
|
| -MaybeObject* CallStubCompiler::GenerateMissBranch() {
|
| - MaybeObject* maybe_obj =
|
| +void CallStubCompiler::GenerateMissBranch() {
|
| + Handle<Code> code =
|
| isolate()->stub_cache()->ComputeCallMiss(arguments().immediate(),
|
| kind_,
|
| - extra_ic_state_);
|
| + extra_state_);
|
| + __ jmp(code, RelocInfo::CODE_TARGET);
|
| +}
|
| +
|
| +
|
| +// TODO(kmillikin): Eliminate this function when the stub cache is fully
|
| +// handlified.
|
| +MaybeObject* CallStubCompiler::TryGenerateMissBranch() {
|
| + MaybeObject* maybe_obj =
|
| + isolate()->stub_cache()->TryComputeCallMiss(arguments().immediate(),
|
| + kind_,
|
| + extra_state_);
|
| Object* obj;
|
| if (!maybe_obj->ToObject(&obj)) return maybe_obj;
|
| __ jmp(Handle<Code>(Code::cast(obj)), RelocInfo::CODE_TARGET);
|
| @@ -1347,11 +1556,10 @@
|
| }
|
|
|
|
|
| -MUST_USE_RESULT MaybeObject* CallStubCompiler::CompileCallField(
|
| - JSObject* object,
|
| - JSObject* holder,
|
| - int index,
|
| - String* name) {
|
| +Handle<Code> CallStubCompiler::CompileCallField(Handle<JSObject> object,
|
| + Handle<JSObject> holder,
|
| + int index,
|
| + Handle<String> name) {
|
| // ----------- S t a t e -------------
|
| // -- ecx : name
|
| // -- esp[0] : return address
|
| @@ -1389,7 +1597,7 @@
|
| }
|
|
|
| // Invoke the function.
|
| - CallKind call_kind = CallICBase::Contextual::decode(extra_ic_state_)
|
| + CallKind call_kind = CallICBase::Contextual::decode(extra_state_)
|
| ? CALL_AS_FUNCTION
|
| : CALL_AS_METHOD;
|
| __ InvokeFunction(edi, arguments(), JUMP_FUNCTION,
|
| @@ -1397,8 +1605,7 @@
|
|
|
| // Handle call cache miss.
|
| __ bind(&miss);
|
| - MaybeObject* maybe_result = GenerateMissBranch();
|
| - if (maybe_result->IsFailure()) return maybe_result;
|
| + GenerateMissBranch();
|
|
|
| // Return the generated code.
|
| return GetCode(FIELD, name);
|
| @@ -1425,7 +1632,7 @@
|
|
|
| Label miss;
|
|
|
| - GenerateNameCheck(name, &miss);
|
| + GenerateNameCheck(Handle<String>(name), &miss);
|
|
|
| // Get the receiver from the stack.
|
| const int argc = arguments().immediate();
|
| @@ -1513,8 +1720,8 @@
|
| // the new element is non-Smi. For now, delegate to the builtin.
|
| Label no_fast_elements_check;
|
| __ JumpIfSmi(edi, &no_fast_elements_check);
|
| - __ mov(esi, FieldOperand(edx, HeapObject::kMapOffset));
|
| - __ CheckFastObjectElements(esi, &call_builtin, Label::kFar);
|
| + __ mov(ecx, FieldOperand(edx, HeapObject::kMapOffset));
|
| + __ CheckFastObjectElements(ecx, &call_builtin, Label::kFar);
|
| __ bind(&no_fast_elements_check);
|
|
|
| // We could be lucky and the elements array could be at the top of
|
| @@ -1582,11 +1789,11 @@
|
| }
|
|
|
| __ bind(&miss);
|
| - MaybeObject* maybe_result = GenerateMissBranch();
|
| + MaybeObject* maybe_result = TryGenerateMissBranch();
|
| if (maybe_result->IsFailure()) return maybe_result;
|
|
|
| // Return the generated code.
|
| - return GetCode(function);
|
| + return TryGetCode(function);
|
| }
|
|
|
|
|
| @@ -1610,7 +1817,7 @@
|
|
|
| Label miss, return_undefined, call_builtin;
|
|
|
| - GenerateNameCheck(name, &miss);
|
| + GenerateNameCheck(Handle<String>(name), &miss);
|
|
|
| // Get the receiver from the stack.
|
| const int argc = arguments().immediate();
|
| @@ -1665,11 +1872,11 @@
|
| 1);
|
|
|
| __ bind(&miss);
|
| - MaybeObject* maybe_result = GenerateMissBranch();
|
| + MaybeObject* maybe_result = TryGenerateMissBranch();
|
| if (maybe_result->IsFailure()) return maybe_result;
|
|
|
| // Return the generated code.
|
| - return GetCode(function);
|
| + return TryGetCode(function);
|
| }
|
|
|
|
|
| @@ -1700,12 +1907,12 @@
|
| Label* index_out_of_range_label = &index_out_of_range;
|
|
|
| if (kind_ == Code::CALL_IC &&
|
| - (CallICBase::StringStubState::decode(extra_ic_state_) ==
|
| + (CallICBase::StringStubState::decode(extra_state_) ==
|
| DEFAULT_STRING_STUB)) {
|
| index_out_of_range_label = &miss;
|
| }
|
|
|
| - GenerateNameCheck(name, &name_miss);
|
| + GenerateNameCheck(Handle<String>(name), &name_miss);
|
|
|
| // Check that the maps starting from the prototype haven't changed.
|
| GenerateDirectLoadGlobalFunctionPrototype(masm(),
|
| @@ -1751,11 +1958,11 @@
|
| // Restore function name in ecx.
|
| __ Set(ecx, Immediate(Handle<String>(name)));
|
| __ bind(&name_miss);
|
| - MaybeObject* maybe_result = GenerateMissBranch();
|
| + MaybeObject* maybe_result = TryGenerateMissBranch();
|
| if (maybe_result->IsFailure()) return maybe_result;
|
|
|
| // Return the generated code.
|
| - return GetCode(function);
|
| + return TryGetCode(function);
|
| }
|
|
|
|
|
| @@ -1786,12 +1993,12 @@
|
| Label* index_out_of_range_label = &index_out_of_range;
|
|
|
| if (kind_ == Code::CALL_IC &&
|
| - (CallICBase::StringStubState::decode(extra_ic_state_) ==
|
| + (CallICBase::StringStubState::decode(extra_state_) ==
|
| DEFAULT_STRING_STUB)) {
|
| index_out_of_range_label = &miss;
|
| }
|
|
|
| - GenerateNameCheck(name, &name_miss);
|
| + GenerateNameCheck(Handle<String>(name), &name_miss);
|
|
|
| // Check that the maps starting from the prototype haven't changed.
|
| GenerateDirectLoadGlobalFunctionPrototype(masm(),
|
| @@ -1839,11 +2046,11 @@
|
| // Restore function name in ecx.
|
| __ Set(ecx, Immediate(Handle<String>(name)));
|
| __ bind(&name_miss);
|
| - MaybeObject* maybe_result = GenerateMissBranch();
|
| + MaybeObject* maybe_result = TryGenerateMissBranch();
|
| if (maybe_result->IsFailure()) return maybe_result;
|
|
|
| // Return the generated code.
|
| - return GetCode(function);
|
| + return TryGetCode(function);
|
| }
|
|
|
|
|
| @@ -1870,7 +2077,7 @@
|
| }
|
|
|
| Label miss;
|
| - GenerateNameCheck(name, &miss);
|
| + GenerateNameCheck(Handle<String>(name), &miss);
|
|
|
| if (cell == NULL) {
|
| __ mov(edx, Operand(esp, 2 * kPointerSize));
|
| @@ -1908,7 +2115,7 @@
|
| // Tail call the full function. We do not have to patch the receiver
|
| // because the function makes no use of it.
|
| __ bind(&slow);
|
| - CallKind call_kind = CallICBase::Contextual::decode(extra_ic_state_)
|
| + CallKind call_kind = CallICBase::Contextual::decode(extra_state_)
|
| ? CALL_AS_FUNCTION
|
| : CALL_AS_METHOD;
|
| __ InvokeFunction(function, arguments(), JUMP_FUNCTION,
|
| @@ -1916,11 +2123,11 @@
|
|
|
| __ bind(&miss);
|
| // ecx: function name.
|
| - MaybeObject* maybe_result = GenerateMissBranch();
|
| + MaybeObject* maybe_result = TryGenerateMissBranch();
|
| if (maybe_result->IsFailure()) return maybe_result;
|
|
|
| // Return the generated code.
|
| - return (cell == NULL) ? GetCode(function) : GetCode(NORMAL, name);
|
| + return (cell == NULL) ? TryGetCode(function) : TryGetCode(NORMAL, name);
|
| }
|
|
|
|
|
| @@ -1952,7 +2159,7 @@
|
| }
|
|
|
| Label miss;
|
| - GenerateNameCheck(name, &miss);
|
| + GenerateNameCheck(Handle<String>(name), &miss);
|
|
|
| if (cell == NULL) {
|
| __ mov(edx, Operand(esp, 2 * kPointerSize));
|
| @@ -2045,11 +2252,11 @@
|
|
|
| __ bind(&miss);
|
| // ecx: function name.
|
| - MaybeObject* maybe_result = GenerateMissBranch();
|
| + MaybeObject* maybe_result = TryGenerateMissBranch();
|
| if (maybe_result->IsFailure()) return maybe_result;
|
|
|
| // Return the generated code.
|
| - return (cell == NULL) ? GetCode(function) : GetCode(NORMAL, name);
|
| + return (cell == NULL) ? TryGetCode(function) : TryGetCode(NORMAL, name);
|
| }
|
|
|
|
|
| @@ -2075,7 +2282,7 @@
|
| }
|
|
|
| Label miss;
|
| - GenerateNameCheck(name, &miss);
|
| + GenerateNameCheck(Handle<String>(name), &miss);
|
|
|
| if (cell == NULL) {
|
| __ mov(edx, Operand(esp, 2 * kPointerSize));
|
| @@ -2149,11 +2356,11 @@
|
|
|
| __ bind(&miss);
|
| // ecx: function name.
|
| - MaybeObject* maybe_result = GenerateMissBranch();
|
| + MaybeObject* maybe_result = TryGenerateMissBranch();
|
| if (maybe_result->IsFailure()) return maybe_result;
|
|
|
| // Return the generated code.
|
| - return (cell == NULL) ? GetCode(function) : GetCode(NORMAL, name);
|
| + return (cell == NULL) ? TryGetCode(function) : TryGetCode(NORMAL, name);
|
| }
|
|
|
|
|
| @@ -2176,7 +2383,7 @@
|
|
|
| Label miss, miss_before_stack_reserved;
|
|
|
| - GenerateNameCheck(name, &miss_before_stack_reserved);
|
| + GenerateNameCheck(Handle<String>(name), &miss_before_stack_reserved);
|
|
|
| // Get the receiver from the stack.
|
| const int argc = arguments().immediate();
|
| @@ -2210,11 +2417,11 @@
|
| __ add(esp, Immediate(kFastApiCallArguments * kPointerSize));
|
|
|
| __ bind(&miss_before_stack_reserved);
|
| - MaybeObject* maybe_result = GenerateMissBranch();
|
| + MaybeObject* maybe_result = TryGenerateMissBranch();
|
| if (maybe_result->IsFailure()) return maybe_result;
|
|
|
| // Return the generated code.
|
| - return GetCode(function);
|
| + return TryGetCode(function);
|
| }
|
|
|
|
|
| @@ -2243,7 +2450,7 @@
|
|
|
| Label miss;
|
|
|
| - GenerateNameCheck(name, &miss);
|
| + GenerateNameCheck(Handle<String>(name), &miss);
|
|
|
| // Get the receiver from the stack.
|
| const int argc = arguments().immediate();
|
| @@ -2339,7 +2546,7 @@
|
| UNREACHABLE();
|
| }
|
|
|
| - CallKind call_kind = CallICBase::Contextual::decode(extra_ic_state_)
|
| + CallKind call_kind = CallICBase::Contextual::decode(extra_state_)
|
| ? CALL_AS_FUNCTION
|
| : CALL_AS_METHOD;
|
| __ InvokeFunction(function, arguments(), JUMP_FUNCTION,
|
| @@ -2347,11 +2554,11 @@
|
|
|
| // Handle call cache miss.
|
| __ bind(&miss);
|
| - MaybeObject* maybe_result = GenerateMissBranch();
|
| + MaybeObject* maybe_result = TryGenerateMissBranch();
|
| if (maybe_result->IsFailure()) return maybe_result;
|
|
|
| // Return the generated code.
|
| - return GetCode(function);
|
| + return TryGetCode(function);
|
| }
|
|
|
|
|
| @@ -2367,18 +2574,18 @@
|
| // -----------------------------------
|
| Label miss;
|
|
|
| - GenerateNameCheck(name, &miss);
|
| + GenerateNameCheck(Handle<String>(name), &miss);
|
|
|
| // Get the number of arguments.
|
| const int argc = arguments().immediate();
|
|
|
| - LookupResult lookup;
|
| + LookupResult lookup(isolate());
|
| LookupPostInterceptor(holder, name, &lookup);
|
|
|
| // Get the receiver from the stack.
|
| __ mov(edx, Operand(esp, (argc + 1) * kPointerSize));
|
|
|
| - CallInterceptorCompiler compiler(this, arguments(), ecx, extra_ic_state_);
|
| + CallInterceptorCompiler compiler(this, arguments(), ecx, extra_state_);
|
| MaybeObject* result = compiler.Compile(masm(),
|
| object,
|
| holder,
|
| @@ -2408,7 +2615,7 @@
|
|
|
| // Invoke the function.
|
| __ mov(edi, eax);
|
| - CallKind call_kind = CallICBase::Contextual::decode(extra_ic_state_)
|
| + CallKind call_kind = CallICBase::Contextual::decode(extra_state_)
|
| ? CALL_AS_FUNCTION
|
| : CALL_AS_METHOD;
|
| __ InvokeFunction(edi, arguments(), JUMP_FUNCTION,
|
| @@ -2416,11 +2623,11 @@
|
|
|
| // Handle load cache miss.
|
| __ bind(&miss);
|
| - MaybeObject* maybe_result = GenerateMissBranch();
|
| + MaybeObject* maybe_result = TryGenerateMissBranch();
|
| if (maybe_result->IsFailure()) return maybe_result;
|
|
|
| // Return the generated code.
|
| - return GetCode(INTERCEPTOR, name);
|
| + return TryGetCode(INTERCEPTOR, name);
|
| }
|
|
|
|
|
| @@ -2449,7 +2656,7 @@
|
|
|
| Label miss;
|
|
|
| - GenerateNameCheck(name, &miss);
|
| + GenerateNameCheck(Handle<String>(name), &miss);
|
|
|
| // Get the number of arguments.
|
| const int argc = arguments().immediate();
|
| @@ -2470,40 +2677,32 @@
|
| // Jump to the cached code (tail call).
|
| Counters* counters = isolate()->counters();
|
| __ IncrementCounter(counters->call_global_inline(), 1);
|
| - ASSERT(function->is_compiled());
|
| ParameterCount expected(function->shared()->formal_parameter_count());
|
| - CallKind call_kind = CallICBase::Contextual::decode(extra_ic_state_)
|
| + CallKind call_kind = CallICBase::Contextual::decode(extra_state_)
|
| ? CALL_AS_FUNCTION
|
| : CALL_AS_METHOD;
|
| - if (V8::UseCrankshaft()) {
|
| - // TODO(kasperl): For now, we always call indirectly through the
|
| - // code field in the function to allow recompilation to take effect
|
| - // without changing any of the call sites.
|
| - __ InvokeCode(FieldOperand(edi, JSFunction::kCodeEntryOffset),
|
| - expected, arguments(), JUMP_FUNCTION,
|
| - NullCallWrapper(), call_kind);
|
| - } else {
|
| - Handle<Code> code(function->code());
|
| - __ InvokeCode(code, expected, arguments(),
|
| - RelocInfo::CODE_TARGET, JUMP_FUNCTION,
|
| - NullCallWrapper(), call_kind);
|
| - }
|
| + // We call indirectly through the code field in the function to
|
| + // allow recompilation to take effect without changing any of the
|
| + // call sites.
|
| + __ InvokeCode(FieldOperand(edi, JSFunction::kCodeEntryOffset),
|
| + expected, arguments(), JUMP_FUNCTION,
|
| + NullCallWrapper(), call_kind);
|
|
|
| // Handle call cache miss.
|
| __ bind(&miss);
|
| __ IncrementCounter(counters->call_global_inline_miss(), 1);
|
| - MaybeObject* maybe_result = GenerateMissBranch();
|
| + MaybeObject* maybe_result = TryGenerateMissBranch();
|
| if (maybe_result->IsFailure()) return maybe_result;
|
|
|
| // Return the generated code.
|
| - return GetCode(NORMAL, name);
|
| + return TryGetCode(NORMAL, name);
|
| }
|
|
|
|
|
| -MaybeObject* StoreStubCompiler::CompileStoreField(JSObject* object,
|
| +Handle<Code> StoreStubCompiler::CompileStoreField(Handle<JSObject> object,
|
| int index,
|
| - Map* transition,
|
| - String* name) {
|
| + Handle<Map> transition,
|
| + Handle<String> name) {
|
| // ----------- S t a t e -------------
|
| // -- eax : value
|
| // -- ecx : name
|
| @@ -2513,27 +2712,23 @@
|
| Label miss;
|
|
|
| // Generate store field code. Trashes the name register.
|
| - GenerateStoreField(masm(),
|
| - object,
|
| - index,
|
| - transition,
|
| - edx, ecx, ebx,
|
| - &miss);
|
| + GenerateStoreField(masm(), object, index, transition, edx, ecx, ebx, &miss);
|
|
|
| // Handle store cache miss.
|
| __ bind(&miss);
|
| - __ mov(ecx, Immediate(Handle<String>(name))); // restore name
|
| + __ mov(ecx, Immediate(name)); // restore name
|
| Handle<Code> ic = isolate()->builtins()->StoreIC_Miss();
|
| __ jmp(ic, RelocInfo::CODE_TARGET);
|
|
|
| // Return the generated code.
|
| - return GetCode(transition == NULL ? FIELD : MAP_TRANSITION, name);
|
| + return GetCode(transition.is_null() ? FIELD : MAP_TRANSITION, name);
|
| }
|
|
|
|
|
| -MaybeObject* StoreStubCompiler::CompileStoreCallback(JSObject* object,
|
| - AccessorInfo* callback,
|
| - String* name) {
|
| +Handle<Code> StoreStubCompiler::CompileStoreCallback(
|
| + Handle<JSObject> object,
|
| + Handle<AccessorInfo> callback,
|
| + Handle<String> name) {
|
| // ----------- S t a t e -------------
|
| // -- eax : value
|
| // -- ecx : name
|
| @@ -2561,7 +2756,7 @@
|
|
|
| __ pop(ebx); // remove the return address
|
| __ push(edx); // receiver
|
| - __ push(Immediate(Handle<AccessorInfo>(callback))); // callback info
|
| + __ push(Immediate(callback)); // callback info
|
| __ push(ecx); // name
|
| __ push(eax); // value
|
| __ push(ebx); // restore return address
|
| @@ -2581,8 +2776,9 @@
|
| }
|
|
|
|
|
| -MaybeObject* StoreStubCompiler::CompileStoreInterceptor(JSObject* receiver,
|
| - String* name) {
|
| +Handle<Code> StoreStubCompiler::CompileStoreInterceptor(
|
| + Handle<JSObject> receiver,
|
| + Handle<String> name) {
|
| // ----------- S t a t e -------------
|
| // -- eax : value
|
| // -- ecx : name
|
| @@ -2630,9 +2826,10 @@
|
| }
|
|
|
|
|
| -MaybeObject* StoreStubCompiler::CompileStoreGlobal(GlobalObject* object,
|
| - JSGlobalPropertyCell* cell,
|
| - String* name) {
|
| +Handle<Code> StoreStubCompiler::CompileStoreGlobal(
|
| + Handle<GlobalObject> object,
|
| + Handle<JSGlobalPropertyCell> cell,
|
| + Handle<String> name) {
|
| // ----------- S t a t e -------------
|
| // -- eax : value
|
| // -- ecx : name
|
| @@ -2647,7 +2844,7 @@
|
| __ j(not_equal, &miss);
|
|
|
| // Compute the cell operand to use.
|
| - __ mov(ebx, Immediate(Handle<JSGlobalPropertyCell>(cell)));
|
| + __ mov(ebx, Immediate(cell));
|
| Operand cell_operand = FieldOperand(ebx, JSGlobalPropertyCell::kValueOffset);
|
|
|
| // Check that the value in the cell is not the hole. If it is, this
|
| @@ -2691,10 +2888,10 @@
|
| }
|
|
|
|
|
| -MaybeObject* KeyedStoreStubCompiler::CompileStoreField(JSObject* object,
|
| +Handle<Code> KeyedStoreStubCompiler::CompileStoreField(Handle<JSObject> object,
|
| int index,
|
| - Map* transition,
|
| - String* name) {
|
| + Handle<Map> transition,
|
| + Handle<String> name) {
|
| // ----------- S t a t e -------------
|
| // -- eax : value
|
| // -- ecx : key
|
| @@ -2707,16 +2904,11 @@
|
| __ IncrementCounter(counters->keyed_store_field(), 1);
|
|
|
| // Check that the name has not changed.
|
| - __ cmp(ecx, Immediate(Handle<String>(name)));
|
| + __ cmp(ecx, Immediate(name));
|
| __ j(not_equal, &miss);
|
|
|
| // Generate store field code. Trashes the name register.
|
| - GenerateStoreField(masm(),
|
| - object,
|
| - index,
|
| - transition,
|
| - edx, ecx, ebx,
|
| - &miss);
|
| + GenerateStoreField(masm(), object, index, transition, edx, ecx, ebx, &miss);
|
|
|
| // Handle store cache miss.
|
| __ bind(&miss);
|
| @@ -2725,40 +2917,37 @@
|
| __ jmp(ic, RelocInfo::CODE_TARGET);
|
|
|
| // Return the generated code.
|
| - return GetCode(transition == NULL ? FIELD : MAP_TRANSITION, name);
|
| + return GetCode(transition.is_null() ? FIELD : MAP_TRANSITION, name);
|
| }
|
|
|
|
|
| -MaybeObject* KeyedStoreStubCompiler::CompileStoreElement(Map* receiver_map) {
|
| +Handle<Code> KeyedStoreStubCompiler::CompileStoreElement(
|
| + Handle<Map> receiver_map) {
|
| // ----------- S t a t e -------------
|
| // -- eax : value
|
| // -- ecx : key
|
| // -- edx : receiver
|
| // -- esp[0] : return address
|
| // -----------------------------------
|
| - Code* stub;
|
| ElementsKind elements_kind = receiver_map->elements_kind();
|
| bool is_jsarray = receiver_map->instance_type() == JS_ARRAY_TYPE;
|
| - MaybeObject* maybe_stub =
|
| - KeyedStoreElementStub(is_jsarray, elements_kind).TryGetCode();
|
| - if (!maybe_stub->To(&stub)) return maybe_stub;
|
| - __ DispatchMap(edx,
|
| - Handle<Map>(receiver_map),
|
| - Handle<Code>(stub),
|
| - DO_SMI_CHECK);
|
| + Handle<Code> stub =
|
| + KeyedStoreElementStub(is_jsarray, elements_kind).GetCode();
|
|
|
| + __ DispatchMap(edx, receiver_map, stub, DO_SMI_CHECK);
|
| +
|
| Handle<Code> ic = isolate()->builtins()->KeyedStoreIC_Miss();
|
| __ jmp(ic, RelocInfo::CODE_TARGET);
|
|
|
| // Return the generated code.
|
| - return GetCode(NORMAL, NULL);
|
| + return GetCode(NORMAL, factory()->empty_string());
|
| }
|
|
|
|
|
| -MaybeObject* KeyedStoreStubCompiler::CompileStorePolymorphic(
|
| - MapList* receiver_maps,
|
| - CodeList* handler_stubs,
|
| - MapList* transitioned_maps) {
|
| +Handle<Code> KeyedStoreStubCompiler::CompileStorePolymorphic(
|
| + MapHandleList* receiver_maps,
|
| + CodeHandleList* handler_stubs,
|
| + MapHandleList* transitioned_maps) {
|
| // ----------- S t a t e -------------
|
| // -- eax : value
|
| // -- ecx : key
|
| @@ -2770,15 +2959,14 @@
|
| __ mov(edi, FieldOperand(edx, HeapObject::kMapOffset));
|
| // ebx: receiver->map().
|
| for (int i = 0; i < receiver_maps->length(); ++i) {
|
| - Handle<Map> map(receiver_maps->at(i));
|
| - __ cmp(edi, map);
|
| - if (transitioned_maps->at(i) == NULL) {
|
| - __ j(equal, Handle<Code>(handler_stubs->at(i)));
|
| + __ cmp(edi, receiver_maps->at(i));
|
| + if (transitioned_maps->at(i).is_null()) {
|
| + __ j(equal, handler_stubs->at(i));
|
| } else {
|
| Label next_map;
|
| __ j(not_equal, &next_map, Label::kNear);
|
| - __ mov(ebx, Immediate(Handle<Map>(transitioned_maps->at(i))));
|
| - __ jmp(Handle<Code>(handler_stubs->at(i)), RelocInfo::CODE_TARGET);
|
| + __ mov(ebx, Immediate(transitioned_maps->at(i)));
|
| + __ jmp(handler_stubs->at(i), RelocInfo::CODE_TARGET);
|
| __ bind(&next_map);
|
| }
|
| }
|
| @@ -2787,13 +2975,13 @@
|
| __ jmp(miss_ic, RelocInfo::CODE_TARGET);
|
|
|
| // Return the generated code.
|
| - return GetCode(NORMAL, NULL, MEGAMORPHIC);
|
| + return GetCode(NORMAL, factory()->empty_string(), MEGAMORPHIC);
|
| }
|
|
|
|
|
| -MaybeObject* LoadStubCompiler::CompileLoadNonexistent(String* name,
|
| - JSObject* object,
|
| - JSObject* last) {
|
| +Handle<Code> LoadStubCompiler::CompileLoadNonexistent(Handle<String> name,
|
| + Handle<JSObject> object,
|
| + Handle<JSObject> last) {
|
| // ----------- S t a t e -------------
|
| // -- eax : receiver
|
| // -- ecx : name
|
| @@ -2814,15 +3002,8 @@
|
| // If the last object in the prototype chain is a global object,
|
| // check that the global property cell is empty.
|
| if (last->IsGlobalObject()) {
|
| - MaybeObject* cell = GenerateCheckPropertyCell(masm(),
|
| - GlobalObject::cast(last),
|
| - name,
|
| - edx,
|
| - &miss);
|
| - if (cell->IsFailure()) {
|
| - miss.Unuse();
|
| - return cell;
|
| - }
|
| + GenerateCheckPropertyCell(
|
| + masm(), Handle<GlobalObject>::cast(last), name, edx, &miss);
|
| }
|
|
|
| // Return undefined if maps of the full prototype chain are still the
|
| @@ -2834,14 +3015,14 @@
|
| GenerateLoadMiss(masm(), Code::LOAD_IC);
|
|
|
| // Return the generated code.
|
| - return GetCode(NONEXISTENT, isolate()->heap()->empty_string());
|
| + return GetCode(NONEXISTENT, factory()->empty_string());
|
| }
|
|
|
|
|
| -MaybeObject* LoadStubCompiler::CompileLoadField(JSObject* object,
|
| - JSObject* holder,
|
| +Handle<Code> LoadStubCompiler::CompileLoadField(Handle<JSObject> object,
|
| + Handle<JSObject> holder,
|
| int index,
|
| - String* name) {
|
| + Handle<String> name) {
|
| // ----------- S t a t e -------------
|
| // -- eax : receiver
|
| // -- ecx : name
|
| @@ -2880,14 +3061,14 @@
|
| GenerateLoadMiss(masm(), Code::LOAD_IC);
|
|
|
| // Return the generated code.
|
| - return GetCode(CALLBACKS, name);
|
| + return TryGetCode(CALLBACKS, name);
|
| }
|
|
|
|
|
| -MaybeObject* LoadStubCompiler::CompileLoadConstant(JSObject* object,
|
| - JSObject* holder,
|
| - Object* value,
|
| - String* name) {
|
| +Handle<Code> LoadStubCompiler::CompileLoadConstant(Handle<JSObject> object,
|
| + Handle<JSObject> holder,
|
| + Handle<Object> value,
|
| + Handle<String> name) {
|
| // ----------- S t a t e -------------
|
| // -- eax : receiver
|
| // -- ecx : name
|
| @@ -2914,7 +3095,7 @@
|
| // -----------------------------------
|
| Label miss;
|
|
|
| - LookupResult lookup;
|
| + LookupResult lookup(isolate());
|
| LookupPostInterceptor(holder, name, &lookup);
|
|
|
| // TODO(368): Compile in the whole chain: all the interceptors in
|
| @@ -2934,15 +3115,16 @@
|
| GenerateLoadMiss(masm(), Code::LOAD_IC);
|
|
|
| // Return the generated code.
|
| - return GetCode(INTERCEPTOR, name);
|
| + return TryGetCode(INTERCEPTOR, name);
|
| }
|
|
|
|
|
| -MaybeObject* LoadStubCompiler::CompileLoadGlobal(JSObject* object,
|
| - GlobalObject* holder,
|
| - JSGlobalPropertyCell* cell,
|
| - String* name,
|
| - bool is_dont_delete) {
|
| +Handle<Code> LoadStubCompiler::CompileLoadGlobal(
|
| + Handle<JSObject> object,
|
| + Handle<GlobalObject> holder,
|
| + Handle<JSGlobalPropertyCell> cell,
|
| + Handle<String> name,
|
| + bool is_dont_delete) {
|
| // ----------- S t a t e -------------
|
| // -- eax : receiver
|
| // -- ecx : name
|
| @@ -2953,7 +3135,7 @@
|
| // If the object is the holder then we know that it's a global
|
| // object which can only happen for contextual loads. In this case,
|
| // the receiver cannot be a smi.
|
| - if (object != holder) {
|
| + if (!object.is_identical_to(holder)) {
|
| __ JumpIfSmi(eax, &miss);
|
| }
|
|
|
| @@ -2962,10 +3144,10 @@
|
|
|
| // Get the value from the cell.
|
| if (Serializer::enabled()) {
|
| - __ mov(ebx, Immediate(Handle<JSGlobalPropertyCell>(cell)));
|
| + __ mov(ebx, Immediate(cell));
|
| __ mov(ebx, FieldOperand(ebx, JSGlobalPropertyCell::kValueOffset));
|
| } else {
|
| - __ mov(ebx, Operand::Cell(Handle<JSGlobalPropertyCell>(cell)));
|
| + __ mov(ebx, Operand::Cell(cell));
|
| }
|
|
|
| // Check for deleted property if property can actually be deleted.
|
| @@ -2991,9 +3173,9 @@
|
| }
|
|
|
|
|
| -MaybeObject* KeyedLoadStubCompiler::CompileLoadField(String* name,
|
| - JSObject* receiver,
|
| - JSObject* holder,
|
| +Handle<Code> KeyedLoadStubCompiler::CompileLoadField(Handle<String> name,
|
| + Handle<JSObject> receiver,
|
| + Handle<JSObject> holder,
|
| int index) {
|
| // ----------- S t a t e -------------
|
| // -- eax : key
|
| @@ -3006,7 +3188,7 @@
|
| __ IncrementCounter(counters->keyed_load_field(), 1);
|
|
|
| // Check that the name has not changed.
|
| - __ cmp(eax, Immediate(Handle<String>(name)));
|
| + __ cmp(eax, Immediate(name));
|
| __ j(not_equal, &miss);
|
|
|
| GenerateLoadField(receiver, holder, edx, ebx, ecx, edi, index, name, &miss);
|
| @@ -3052,14 +3234,15 @@
|
| GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC);
|
|
|
| // Return the generated code.
|
| - return GetCode(CALLBACKS, name);
|
| + return TryGetCode(CALLBACKS, name);
|
| }
|
|
|
|
|
| -MaybeObject* KeyedLoadStubCompiler::CompileLoadConstant(String* name,
|
| - JSObject* receiver,
|
| - JSObject* holder,
|
| - Object* value) {
|
| +Handle<Code> KeyedLoadStubCompiler::CompileLoadConstant(
|
| + Handle<String> name,
|
| + Handle<JSObject> receiver,
|
| + Handle<JSObject> holder,
|
| + Handle<Object> value) {
|
| // ----------- S t a t e -------------
|
| // -- eax : key
|
| // -- edx : receiver
|
| @@ -3071,11 +3254,11 @@
|
| __ IncrementCounter(counters->keyed_load_constant_function(), 1);
|
|
|
| // Check that the name has not changed.
|
| - __ cmp(eax, Immediate(Handle<String>(name)));
|
| + __ cmp(eax, Immediate(name));
|
| __ j(not_equal, &miss);
|
|
|
| - GenerateLoadConstant(receiver, holder, edx, ebx, ecx, edi,
|
| - value, name, &miss);
|
| + GenerateLoadConstant(
|
| + receiver, holder, edx, ebx, ecx, edi, value, name, &miss);
|
| __ bind(&miss);
|
| __ DecrementCounter(counters->keyed_load_constant_function(), 1);
|
| GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC);
|
| @@ -3102,7 +3285,7 @@
|
| __ cmp(eax, Immediate(Handle<String>(name)));
|
| __ j(not_equal, &miss);
|
|
|
| - LookupResult lookup;
|
| + LookupResult lookup(isolate());
|
| LookupPostInterceptor(holder, name, &lookup);
|
| GenerateLoadInterceptor(receiver,
|
| holder,
|
| @@ -3119,11 +3302,12 @@
|
| GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC);
|
|
|
| // Return the generated code.
|
| - return GetCode(INTERCEPTOR, name);
|
| + return TryGetCode(INTERCEPTOR, name);
|
| }
|
|
|
|
|
| -MaybeObject* KeyedLoadStubCompiler::CompileLoadArrayLength(String* name) {
|
| +Handle<Code> KeyedLoadStubCompiler::CompileLoadArrayLength(
|
| + Handle<String> name) {
|
| // ----------- S t a t e -------------
|
| // -- eax : key
|
| // -- edx : receiver
|
| @@ -3135,7 +3319,7 @@
|
| __ IncrementCounter(counters->keyed_load_array_length(), 1);
|
|
|
| // Check that the name has not changed.
|
| - __ cmp(eax, Immediate(Handle<String>(name)));
|
| + __ cmp(eax, Immediate(name));
|
| __ j(not_equal, &miss);
|
|
|
| GenerateLoadArrayLength(masm(), edx, ecx, &miss);
|
| @@ -3148,7 +3332,8 @@
|
| }
|
|
|
|
|
| -MaybeObject* KeyedLoadStubCompiler::CompileLoadStringLength(String* name) {
|
| +Handle<Code> KeyedLoadStubCompiler::CompileLoadStringLength(
|
| + Handle<String> name) {
|
| // ----------- S t a t e -------------
|
| // -- eax : key
|
| // -- edx : receiver
|
| @@ -3160,7 +3345,7 @@
|
| __ IncrementCounter(counters->keyed_load_string_length(), 1);
|
|
|
| // Check that the name has not changed.
|
| - __ cmp(eax, Immediate(Handle<String>(name)));
|
| + __ cmp(eax, Immediate(name));
|
| __ j(not_equal, &miss);
|
|
|
| GenerateLoadStringLength(masm(), edx, ecx, ebx, &miss, true);
|
| @@ -3173,7 +3358,8 @@
|
| }
|
|
|
|
|
| -MaybeObject* KeyedLoadStubCompiler::CompileLoadFunctionPrototype(String* name) {
|
| +Handle<Code> KeyedLoadStubCompiler::CompileLoadFunctionPrototype(
|
| + Handle<String> name) {
|
| // ----------- S t a t e -------------
|
| // -- eax : key
|
| // -- edx : receiver
|
| @@ -3185,7 +3371,7 @@
|
| __ IncrementCounter(counters->keyed_load_function_prototype(), 1);
|
|
|
| // Check that the name has not changed.
|
| - __ cmp(eax, Immediate(Handle<String>(name)));
|
| + __ cmp(eax, Immediate(name));
|
| __ j(not_equal, &miss);
|
|
|
| GenerateLoadFunctionPrototype(masm(), edx, ecx, ebx, &miss);
|
| @@ -3198,31 +3384,29 @@
|
| }
|
|
|
|
|
| -MaybeObject* KeyedLoadStubCompiler::CompileLoadElement(Map* receiver_map) {
|
| +Handle<Code> KeyedLoadStubCompiler::CompileLoadElement(
|
| + Handle<Map> receiver_map) {
|
| // ----------- S t a t e -------------
|
| // -- eax : key
|
| // -- edx : receiver
|
| // -- esp[0] : return address
|
| // -----------------------------------
|
| - Code* stub;
|
| +
|
| ElementsKind elements_kind = receiver_map->elements_kind();
|
| - MaybeObject* maybe_stub = KeyedLoadElementStub(elements_kind).TryGetCode();
|
| - if (!maybe_stub->To(&stub)) return maybe_stub;
|
| - __ DispatchMap(edx,
|
| - Handle<Map>(receiver_map),
|
| - Handle<Code>(stub),
|
| - DO_SMI_CHECK);
|
| + Handle<Code> stub = KeyedLoadElementStub(elements_kind).GetCode();
|
|
|
| + __ DispatchMap(edx, receiver_map, stub, DO_SMI_CHECK);
|
| +
|
| GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC);
|
|
|
| // Return the generated code.
|
| - return GetCode(NORMAL, NULL);
|
| + return GetCode(NORMAL, factory()->empty_string());
|
| }
|
|
|
|
|
| -MaybeObject* KeyedLoadStubCompiler::CompileLoadPolymorphic(
|
| - MapList* receiver_maps,
|
| - CodeList* handler_ics) {
|
| +Handle<Code> KeyedLoadStubCompiler::CompileLoadPolymorphic(
|
| + MapHandleList* receiver_maps,
|
| + CodeHandleList* handler_ics) {
|
| // ----------- S t a t e -------------
|
| // -- eax : key
|
| // -- edx : receiver
|
| @@ -3235,16 +3419,15 @@
|
| __ mov(map_reg, FieldOperand(edx, HeapObject::kMapOffset));
|
| int receiver_count = receiver_maps->length();
|
| for (int current = 0; current < receiver_count; ++current) {
|
| - Handle<Map> map(receiver_maps->at(current));
|
| - __ cmp(map_reg, map);
|
| - __ j(equal, Handle<Code>(handler_ics->at(current)));
|
| + __ cmp(map_reg, receiver_maps->at(current));
|
| + __ j(equal, handler_ics->at(current));
|
| }
|
|
|
| __ bind(&miss);
|
| GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC);
|
|
|
| // Return the generated code.
|
| - return GetCode(NORMAL, NULL, MEGAMORPHIC);
|
| + return GetCode(NORMAL, factory()->empty_string(), MEGAMORPHIC);
|
| }
|
|
|
|
|
|
|
Chromium Code Reviews
