| Index: src/a64/stub-cache-a64.cc
|
| diff --git a/src/a64/stub-cache-a64.cc b/src/a64/stub-cache-a64.cc
|
| index 55cdf76c2e6c88f6177d402d0c08740db1236b8b..bbcb64be1fa57a5220517ce57038bd36df9fcaed 100644
|
| --- a/src/a64/stub-cache-a64.cc
|
| +++ b/src/a64/stub-cache-a64.cc
|
| @@ -273,7 +273,7 @@ void StubCompiler::GenerateFastPropertyLoad(MacroAssembler* masm,
|
| bool inobject,
|
| int index,
|
| Representation representation) {
|
| - ASSERT(!FLAG_track_double_fields || !representation.IsDouble());
|
| + ASSERT(!representation.IsDouble());
|
| USE(representation);
|
| if (inobject) {
|
| int offset = index * kPointerSize;
|
| @@ -306,60 +306,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.
|
| -static void GenerateStringCheck(MacroAssembler* masm,
|
| - Register receiver,
|
| - Register scratch1,
|
| - Label* smi,
|
| - Label* non_string_object) {
|
| - // Check that the receiver isn't a smi.
|
| - __ JumpIfSmi(receiver, smi);
|
| -
|
| - // Get the object's instance type filed.
|
| - __ Ldr(scratch1, FieldMemOperand(receiver, HeapObject::kMapOffset));
|
| - __ Ldrb(scratch1, FieldMemOperand(scratch1, Map::kInstanceTypeOffset));
|
| - // Check if the "not string" bit is set.
|
| - __ Tbnz(scratch1, MaskToBit(kNotStringTag), 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 not clobbered if the receiver is not a string.
|
| -void StubCompiler::GenerateLoadStringLength(MacroAssembler* masm,
|
| - Register receiver,
|
| - Register scratch1,
|
| - Register scratch2,
|
| - Label* miss) {
|
| - // Input registers can't alias because we don't want to clobber the
|
| - // receiver register if the object is not a string.
|
| - ASSERT(!AreAliased(receiver, scratch1, scratch2));
|
| -
|
| - Label check_wrapper;
|
| -
|
| - // Check if the object is a string leaving the instance type in the
|
| - // scratch1 register.
|
| - GenerateStringCheck(masm, receiver, scratch1, miss, &check_wrapper);
|
| -
|
| - // Load length directly from the string.
|
| - __ Ldr(x0, 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, miss, miss);
|
| - __ Ldr(x0, FieldMemOperand(scratch1, String::kLengthOffset));
|
| - __ Ret();
|
| -}
|
| -
|
| -
|
| void StubCompiler::GenerateLoadFunctionPrototype(MacroAssembler* masm,
|
| Register receiver,
|
| Register scratch1,
|
| @@ -443,11 +389,11 @@ void StoreStubCompiler::GenerateStoreTransition(MacroAssembler* masm,
|
| __ LoadObject(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;
|
| __ AllocateHeapNumber(storage_reg, slow, scratch1, scratch2);
|
|
|
| @@ -520,15 +466,15 @@ void StoreStubCompiler::GenerateStoreTransition(MacroAssembler* masm,
|
| int offset = object->map()->instance_size() + (index * kPointerSize);
|
| // TODO(jbramley): This construct appears in several places in this
|
| // function. Try to clean it up, perhaps using a result_reg.
|
| - 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,
|
| @@ -546,15 +492,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,
|
| @@ -604,11 +550,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 = (index * kPointerSize) + object->map()->instance_size();
|
| @@ -650,7 +596,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);
|
|
|
| @@ -674,7 +620,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);
|
|
|
| @@ -903,7 +849,8 @@ Register StubCompiler::CheckPrototypes(Handle<HeapType> type,
|
| // the map check so that we know that the object is actually a global
|
| // object.
|
| if (current_map->IsJSGlobalProxyMap()) {
|
| - __ CheckAccessGlobalProxy(reg, scratch2, miss);
|
| + UseScratchRegisterScope temps(masm());
|
| + __ CheckAccessGlobalProxy(reg, scratch2, temps.AcquireX(), miss);
|
| } else if (current_map->IsJSGlobalObjectMap()) {
|
| GenerateCheckPropertyCell(
|
| masm(), Handle<JSGlobalObject>::cast(current), name,
|
| @@ -940,7 +887,7 @@ Register StubCompiler::CheckPrototypes(Handle<HeapType> type,
|
| ASSERT(current_map->IsJSGlobalProxyMap() ||
|
| !current_map->is_access_check_needed());
|
| if (current_map->IsJSGlobalProxyMap()) {
|
| - __ CheckAccessGlobalProxy(reg, scratch1, miss);
|
| + __ CheckAccessGlobalProxy(reg, scratch1, scratch2, miss);
|
| }
|
|
|
| // Return the register containing the holder.
|
| @@ -1239,22 +1186,18 @@ Handle<Code> StoreStubCompiler::CompileStoreCallback(
|
| void StoreStubCompiler::GenerateStoreViaSetter(
|
| MacroAssembler* masm,
|
| Handle<HeapType> type,
|
| + Register receiver,
|
| Handle<JSFunction> setter) {
|
| // ----------- S t a t e -------------
|
| - // -- x0 : value
|
| - // -- x1 : receiver
|
| - // -- x2 : name
|
| // -- lr : return address
|
| // -----------------------------------
|
| - Register value = x0;
|
| - Register receiver = x1;
|
| Label miss;
|
|
|
| {
|
| FrameScope 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.
|
| @@ -1264,7 +1207,7 @@ void StoreStubCompiler::GenerateStoreViaSetter(
|
| FieldMemOperand(
|
| receiver, JSGlobalObject::kGlobalReceiverOffset));
|
| }
|
| - __ Push(receiver, value);
|
| + __ Push(receiver, value());
|
| ParameterCount actual(1);
|
| ParameterCount expected(setter);
|
| __ InvokeFunction(setter, expected, actual,
|
| @@ -1276,7 +1219,7 @@ void StoreStubCompiler::GenerateStoreViaSetter(
|
| }
|
|
|
| // We have to return the passed value, not the return value of the setter.
|
| - __ Pop(value);
|
| + __ Pop(x0);
|
|
|
| // Restore context register.
|
| __ Ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
|
| @@ -1343,16 +1286,21 @@ Register* KeyedLoadStubCompiler::registers() {
|
| }
|
|
|
|
|
| +Register StoreStubCompiler::value() {
|
| + return x0;
|
| +}
|
| +
|
| +
|
| Register* StoreStubCompiler::registers() {
|
| - // receiver, name, value, scratch1, scratch2, scratch3.
|
| - static Register registers[] = { x1, x2, x0, x3, x4, x5 };
|
| + // receiver, value, scratch1, scratch2, scratch3.
|
| + static Register registers[] = { x1, x2, x3, x4, x5 };
|
| return registers;
|
| }
|
|
|
|
|
| Register* KeyedStoreStubCompiler::registers() {
|
| - // receiver, name, value, scratch1, scratch2, scratch3.
|
| - static Register registers[] = { x2, x1, x0, x3, x4, x5 };
|
| + // receiver, name, scratch1, scratch2, scratch3.
|
| + static Register registers[] = { x2, x1, x3, x4, x5 };
|
| return registers;
|
| }
|
|
|
|
|