| Index: src/arm/stub-cache-arm.cc
|
| diff --git a/src/arm/stub-cache-arm.cc b/src/arm/stub-cache-arm.cc
|
| index 0c7df71eaf646d0cdb451a05035843daa77e1359..35aab5f2de46366a4ee6df6add65d6bcdb77c69a 100644
|
| --- a/src/arm/stub-cache-arm.cc
|
| +++ b/src/arm/stub-cache-arm.cc
|
| @@ -322,7 +322,7 @@ void StubCompiler::GenerateFastPropertyLoad(MacroAssembler* masm,
|
| bool inobject,
|
| int index,
|
| Representation representation) {
|
| - ASSERT(!FLAG_track_double_fields || !representation.IsDouble());
|
| + ASSERT(!representation.IsDouble());
|
| int offset = index * kPointerSize;
|
| if (!inobject) {
|
| // Calculate the offset into the properties array.
|
| @@ -351,60 +351,6 @@ void StubCompiler::GenerateLoadArrayLength(MacroAssembler* masm,
|
| }
|
|
|
|
|
| -// Generate code to check if an object is a string. If the object is a
|
| -// heap object, its map's instance type is left in the scratch1 register.
|
| -// If this is not needed, scratch1 and scratch2 may be the same register.
|
| -static void GenerateStringCheck(MacroAssembler* masm,
|
| - Register receiver,
|
| - Register scratch1,
|
| - Register scratch2,
|
| - Label* smi,
|
| - Label* non_string_object) {
|
| - // Check that the receiver isn't a smi.
|
| - __ JumpIfSmi(receiver, smi);
|
| -
|
| - // Check that the object is a string.
|
| - __ ldr(scratch1, FieldMemOperand(receiver, HeapObject::kMapOffset));
|
| - __ ldrb(scratch1, FieldMemOperand(scratch1, Map::kInstanceTypeOffset));
|
| - __ and_(scratch2, scratch1, Operand(kIsNotStringMask));
|
| - // The cast is to resolve the overload for the argument of 0x0.
|
| - __ cmp(scratch2, Operand(static_cast<int32_t>(kStringTag)));
|
| - __ b(ne, non_string_object);
|
| -}
|
| -
|
| -
|
| -// Generate code to load the length from a string object and return the length.
|
| -// If the receiver object is not a string or a wrapped string object the
|
| -// execution continues at the miss label. The register containing the
|
| -// receiver is potentially clobbered.
|
| -void StubCompiler::GenerateLoadStringLength(MacroAssembler* masm,
|
| - Register receiver,
|
| - Register scratch1,
|
| - Register scratch2,
|
| - Label* miss) {
|
| - Label check_wrapper;
|
| -
|
| - // Check if the object is a string leaving the instance type in the
|
| - // scratch1 register.
|
| - GenerateStringCheck(masm, receiver, scratch1, scratch2, miss, &check_wrapper);
|
| -
|
| - // Load length directly from the string.
|
| - __ ldr(r0, FieldMemOperand(receiver, String::kLengthOffset));
|
| - __ Ret();
|
| -
|
| - // Check if the object is a JSValue wrapper.
|
| - __ bind(&check_wrapper);
|
| - __ cmp(scratch1, Operand(JS_VALUE_TYPE));
|
| - __ b(ne, miss);
|
| -
|
| - // Unwrap the value and check if the wrapped value is a string.
|
| - __ ldr(scratch1, FieldMemOperand(receiver, JSValue::kValueOffset));
|
| - GenerateStringCheck(masm, scratch1, scratch2, scratch2, miss, miss);
|
| - __ ldr(r0, FieldMemOperand(scratch1, String::kLengthOffset));
|
| - __ Ret();
|
| -}
|
| -
|
| -
|
| void StubCompiler::GenerateLoadFunctionPrototype(MacroAssembler* masm,
|
| Register receiver,
|
| Register scratch1,
|
| @@ -481,11 +427,11 @@ void StoreStubCompiler::GenerateStoreTransition(MacroAssembler* masm,
|
| __ Move(scratch1, constant);
|
| __ cmp(value_reg, scratch1);
|
| __ b(ne, miss_label);
|
| - } else if (FLAG_track_fields && representation.IsSmi()) {
|
| + } else if (representation.IsSmi()) {
|
| __ JumpIfNotSmi(value_reg, miss_label);
|
| - } else if (FLAG_track_heap_object_fields && representation.IsHeapObject()) {
|
| + } else if (representation.IsHeapObject()) {
|
| __ JumpIfSmi(value_reg, miss_label);
|
| - } else if (FLAG_track_double_fields && representation.IsDouble()) {
|
| + } else if (representation.IsDouble()) {
|
| Label do_store, heap_number;
|
| __ LoadRoot(scratch3, Heap::kHeapNumberMapRootIndex);
|
| __ AllocateHeapNumber(storage_reg, scratch1, scratch2, scratch3, slow);
|
| @@ -559,15 +505,15 @@ void StoreStubCompiler::GenerateStoreTransition(MacroAssembler* masm,
|
| if (index < 0) {
|
| // Set the property straight into the object.
|
| int offset = object->map()->instance_size() + (index * kPointerSize);
|
| - if (FLAG_track_double_fields && representation.IsDouble()) {
|
| + if (representation.IsDouble()) {
|
| __ str(storage_reg, FieldMemOperand(receiver_reg, offset));
|
| } else {
|
| __ str(value_reg, FieldMemOperand(receiver_reg, offset));
|
| }
|
|
|
| - if (!FLAG_track_fields || !representation.IsSmi()) {
|
| + if (!representation.IsSmi()) {
|
| // Update the write barrier for the array address.
|
| - if (!FLAG_track_double_fields || !representation.IsDouble()) {
|
| + if (!representation.IsDouble()) {
|
| __ mov(storage_reg, value_reg);
|
| }
|
| __ RecordWriteField(receiver_reg,
|
| @@ -585,15 +531,15 @@ void StoreStubCompiler::GenerateStoreTransition(MacroAssembler* masm,
|
| // Get the properties array
|
| __ ldr(scratch1,
|
| FieldMemOperand(receiver_reg, JSObject::kPropertiesOffset));
|
| - if (FLAG_track_double_fields && representation.IsDouble()) {
|
| + if (representation.IsDouble()) {
|
| __ str(storage_reg, FieldMemOperand(scratch1, offset));
|
| } else {
|
| __ str(value_reg, FieldMemOperand(scratch1, offset));
|
| }
|
|
|
| - if (!FLAG_track_fields || !representation.IsSmi()) {
|
| + if (!representation.IsSmi()) {
|
| // Update the write barrier for the array address.
|
| - if (!FLAG_track_double_fields || !representation.IsDouble()) {
|
| + if (!representation.IsDouble()) {
|
| __ mov(storage_reg, value_reg);
|
| }
|
| __ RecordWriteField(scratch1,
|
| @@ -643,11 +589,11 @@ void StoreStubCompiler::GenerateStoreField(MacroAssembler* masm,
|
|
|
| Representation representation = lookup->representation();
|
| ASSERT(!representation.IsNone());
|
| - if (FLAG_track_fields && representation.IsSmi()) {
|
| + if (representation.IsSmi()) {
|
| __ JumpIfNotSmi(value_reg, miss_label);
|
| - } else if (FLAG_track_heap_object_fields && representation.IsHeapObject()) {
|
| + } else if (representation.IsHeapObject()) {
|
| __ JumpIfSmi(value_reg, miss_label);
|
| - } else if (FLAG_track_double_fields && representation.IsDouble()) {
|
| + } else if (representation.IsDouble()) {
|
| // Load the double storage.
|
| if (index < 0) {
|
| int offset = object->map()->instance_size() + (index * kPointerSize);
|
| @@ -688,7 +634,7 @@ void StoreStubCompiler::GenerateStoreField(MacroAssembler* masm,
|
| int offset = object->map()->instance_size() + (index * kPointerSize);
|
| __ str(value_reg, FieldMemOperand(receiver_reg, offset));
|
|
|
| - if (!FLAG_track_fields || !representation.IsSmi()) {
|
| + if (!representation.IsSmi()) {
|
| // Skip updating write barrier if storing a smi.
|
| __ JumpIfSmi(value_reg, &exit);
|
|
|
| @@ -712,7 +658,7 @@ void StoreStubCompiler::GenerateStoreField(MacroAssembler* masm,
|
| FieldMemOperand(receiver_reg, JSObject::kPropertiesOffset));
|
| __ str(value_reg, FieldMemOperand(scratch1, offset));
|
|
|
| - if (!FLAG_track_fields || !representation.IsSmi()) {
|
| + if (!representation.IsSmi()) {
|
| // Skip updating write barrier if storing a smi.
|
| __ JumpIfSmi(value_reg, &exit);
|
|
|
| @@ -1162,7 +1108,7 @@ void LoadStubCompiler::GenerateLoadInterceptor(
|
| // Save necessary data before invoking an interceptor.
|
| // Requires a frame to make GC aware of pushed pointers.
|
| {
|
| - FrameScope frame_scope(masm(), StackFrame::INTERNAL);
|
| + FrameAndConstantPoolScope frame_scope(masm(), StackFrame::INTERNAL);
|
| if (must_preserve_receiver_reg) {
|
| __ Push(receiver(), holder_reg, this->name());
|
| } else {
|
| @@ -1256,20 +1202,16 @@ Handle<Code> StoreStubCompiler::CompileStoreCallback(
|
| void StoreStubCompiler::GenerateStoreViaSetter(
|
| MacroAssembler* masm,
|
| Handle<HeapType> type,
|
| + Register receiver,
|
| Handle<JSFunction> setter) {
|
| // ----------- S t a t e -------------
|
| - // -- r0 : value
|
| - // -- r1 : receiver
|
| - // -- r2 : name
|
| // -- lr : return address
|
| // -----------------------------------
|
| {
|
| - FrameScope scope(masm, StackFrame::INTERNAL);
|
| - Register receiver = r1;
|
| - Register value = r0;
|
| + FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
|
|
|
| // Save value register, so we can restore it later.
|
| - __ push(value);
|
| + __ push(value());
|
|
|
| if (!setter.is_null()) {
|
| // Call the JavaScript setter with receiver and value on the stack.
|
| @@ -1279,7 +1221,7 @@ void StoreStubCompiler::GenerateStoreViaSetter(
|
| FieldMemOperand(
|
| receiver, JSGlobalObject::kGlobalReceiverOffset));
|
| }
|
| - __ Push(receiver, value);
|
| + __ Push(receiver, value());
|
| ParameterCount actual(1);
|
| ParameterCount expected(setter);
|
| __ InvokeFunction(setter, expected, actual,
|
| @@ -1307,21 +1249,6 @@ void StoreStubCompiler::GenerateStoreViaSetter(
|
| Handle<Code> StoreStubCompiler::CompileStoreInterceptor(
|
| Handle<JSObject> object,
|
| Handle<Name> name) {
|
| - Label miss;
|
| -
|
| - // Check that the map of the object hasn't changed.
|
| - __ CheckMap(receiver(), scratch1(), Handle<Map>(object->map()), &miss,
|
| - DO_SMI_CHECK);
|
| -
|
| - // Perform global security token check if needed.
|
| - if (object->IsJSGlobalProxy()) {
|
| - __ CheckAccessGlobalProxy(receiver(), scratch1(), &miss);
|
| - }
|
| -
|
| - // Stub is never generated for non-global objects that require access
|
| - // checks.
|
| - ASSERT(object->IsJSGlobalProxy() || !object->IsAccessCheckNeeded());
|
| -
|
| __ Push(receiver(), this->name(), value());
|
|
|
| // Do tail-call to the runtime system.
|
| @@ -1329,10 +1256,6 @@ Handle<Code> StoreStubCompiler::CompileStoreInterceptor(
|
| ExternalReference(IC_Utility(IC::kStoreInterceptorProperty), isolate());
|
| __ TailCallExternalReference(store_ic_property, 3, 1);
|
|
|
| - // Handle store cache miss.
|
| - __ bind(&miss);
|
| - TailCallBuiltin(masm(), MissBuiltin(kind()));
|
| -
|
| // Return the generated code.
|
| return GetCode(kind(), Code::FAST, name);
|
| }
|
| @@ -1367,16 +1290,21 @@ Register* KeyedLoadStubCompiler::registers() {
|
| }
|
|
|
|
|
| +Register StoreStubCompiler::value() {
|
| + return r0;
|
| +}
|
| +
|
| +
|
| Register* StoreStubCompiler::registers() {
|
| - // receiver, name, value, scratch1, scratch2, scratch3.
|
| - static Register registers[] = { r1, r2, r0, r3, r4, r5 };
|
| + // receiver, name, scratch1, scratch2, scratch3.
|
| + static Register registers[] = { r1, r2, r3, r4, r5 };
|
| return registers;
|
| }
|
|
|
|
|
| Register* KeyedStoreStubCompiler::registers() {
|
| - // receiver, name, value, scratch1, scratch2, scratch3.
|
| - static Register registers[] = { r2, r1, r0, r3, r4, r5 };
|
| + // receiver, name, scratch1, scratch2, scratch3.
|
| + static Register registers[] = { r2, r1, r3, r4, r5 };
|
| return registers;
|
| }
|
|
|
| @@ -1395,7 +1323,7 @@ void LoadStubCompiler::GenerateLoadViaGetter(MacroAssembler* masm,
|
| // -- lr : return address
|
| // -----------------------------------
|
| {
|
| - FrameScope scope(masm, StackFrame::INTERNAL);
|
| + FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
|
|
|
| if (!getter.is_null()) {
|
| // Call the JavaScript getter with the receiver on the stack.
|
|
|