Experimental parser: merge r19949

src/a64/ic-a64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 351 matching lines @@
   __ JumpIfSmi(object, slow_case);
   // Check that the object is some kind of JSObject.
   __ JumpIfObjectType(object, map, scratch1, FIRST_JS_RECEIVER_TYPE,
                       slow_case, lt);
 
   // Check that the key is a positive smi.
   __ JumpIfNotSmi(key, slow_case);
   __ Tbnz(key, kXSignBit, slow_case);
 
   // Load the elements object and check its map.
-  Handle<Map> arguments_map(heap->non_strict_arguments_elements_map());
+  Handle<Map> arguments_map(heap->sloppy_arguments_elements_map());
   __ Ldr(map, FieldMemOperand(object, JSObject::kElementsOffset));
   __ CheckMap(map, scratch1, arguments_map, slow_case, DONT_DO_SMI_CHECK);
 
   // Check if element is in the range of mapped arguments. If not, jump
   // to the unmapped lookup.
   __ Ldr(scratch1, FieldMemOperand(map, FixedArray::kLengthOffset));
   __ Sub(scratch1, scratch1, Operand(Smi::FromInt(2)));
   __ Cmp(key, scratch1);
   __ B(hs, unmapped_case);
 
@@ skipping 84 matching lines @@
   // ----------- S t a t e -------------
   //  -- x2    : name
   //  -- lr    : return address
   //  -- x0    : receiver
   // -----------------------------------
   Isolate* isolate = masm->isolate();
   ASM_LOCATION("LoadIC::GenerateMiss");
 
   __ IncrementCounter(isolate->counters()->load_miss(), 1, x3, x4);
 
-  // TODO(jbramley): Does the target actually expect an argument in x3, or is
-  // this inherited from ARM's push semantics?
-  __ Mov(x3, x0);
-  __ Push(x3, x2);
-
   // Perform tail call to the entry.
+  __ Push(x0, x2);
   ExternalReference ref =
       ExternalReference(IC_Utility(kLoadIC_Miss), isolate);
   __ TailCallExternalReference(ref, 2, 1);
 }
 
 
 void LoadIC::GenerateRuntimeGetProperty(MacroAssembler* masm) {
   // ---------- S t a t e --------------
   //  -- x2    : name
   //  -- lr    : return address
   //  -- x0    : receiver
   // -----------------------------------
 
-  // TODO(jbramley): Does the target actually expect an argument in x3, or is
-  // this inherited from ARM's push semantics?
-  __ Mov(x3, x0);
-  __ Push(x3, x2);
-
+  __ Push(x0, x2);
   __ TailCallRuntime(Runtime::kGetProperty, 2, 1);
 }
 
 
-void KeyedLoadIC::GenerateNonStrictArguments(MacroAssembler* masm) {
+void KeyedLoadIC::GenerateSloppyArguments(MacroAssembler* masm) {
   // ---------- S t a t e --------------
   //  -- lr     : return address
   //  -- x0     : key
   //  -- x1     : receiver
   // -----------------------------------
   Register result = x0;
   Register key = x0;
   Register receiver = x1;
   Label miss, unmapped;
 
@@ skipping 11 matching lines @@
   __ JumpIfRoot(x2, Heap::kTheHoleValueRootIndex, &miss);
   // Move the result in x0. x0 must be preserved on miss.
   __ Mov(result, x2);
   __ Ret();
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
-void KeyedStoreIC::GenerateNonStrictArguments(MacroAssembler* masm) {
-  ASM_LOCATION("KeyedStoreIC::GenerateNonStrictArguments");
+void KeyedStoreIC::GenerateSloppyArguments(MacroAssembler* masm) {
+  ASM_LOCATION("KeyedStoreIC::GenerateSloppyArguments");
   // ---------- S t a t e --------------
   //  -- lr     : return address
   //  -- x0     : value
   //  -- x1     : key
   //  -- x2     : receiver
   // -----------------------------------
 
   Label slow, notin;
 
   Register value = x0;
@@ skipping 374 matching lines @@
 
   // The slow case calls into the runtime to complete the store without causing
   // an IC miss that would otherwise cause a transition to the generic stub.
   ExternalReference ref =
       ExternalReference(IC_Utility(kKeyedStoreIC_Slow), masm->isolate());
   __ TailCallExternalReference(ref, 3, 1);
 }
 
 
 void KeyedStoreIC::GenerateRuntimeSetProperty(MacroAssembler* masm,
-                                              StrictModeFlag strict_mode) {
+                                              StrictMode strict_mode) {
   ASM_LOCATION("KeyedStoreIC::GenerateRuntimeSetProperty");
   // ---------- S t a t e --------------
   //  -- x0     : value
   //  -- x1     : key
   //  -- x2     : receiver
   //  -- lr     : return address
   // -----------------------------------
 
   // Push receiver, key and value for runtime call.
   __ Push(x2, x1, x0);
@@ skipping 34 matching lines @@
     __ Ldr(elements_map, FieldMemOperand(elements, HeapObject::kMapOffset));
     __ Cmp(elements_map,
            Operand(masm->isolate()->factory()->fixed_array_map()));
     __ B(ne, fast_double);
   }
 
   // HOLECHECK: guards "A[i] = V"
   // We have to go to the runtime if the current value is the hole because there
   // may be a callback on the element.
   Label holecheck_passed;
-  // TODO(all): This address calculation is repeated later (for the store
-  // itself). We should keep the result to avoid doing the work twice.
   __ Add(x10, elements, FixedArray::kHeaderSize - kHeapObjectTag);
   __ Add(x10, x10, Operand::UntagSmiAndScale(key, kPointerSizeLog2));
   __ Ldr(x11, MemOperand(x10));
   __ JumpIfNotRoot(x11, Heap::kTheHoleValueRootIndex, &holecheck_passed);
   __ JumpIfDictionaryInPrototypeChain(receiver, elements_map, x10, slow);
   __ bind(&holecheck_passed);
 
   // Smi stores don't require further checks.
   __ JumpIfSmi(value, &finish_store);
 
@@ skipping 32 matching lines @@
   __ Bind(fast_double);
   if (check_map == kCheckMap) {
     // Check for fast double array case. If this fails, call through to the
     // runtime.
     __ JumpIfNotRoot(elements_map, Heap::kFixedDoubleArrayMapRootIndex, slow);
   }
 
   // HOLECHECK: guards "A[i] double hole?"
   // We have to see if the double version of the hole is present. If so go to
   // the runtime.
-  // TODO(all): This address calculation was done earlier. We should keep the
-  // result to avoid doing the work twice.
   __ Add(x10, elements, FixedDoubleArray::kHeaderSize - kHeapObjectTag);
   __ Add(x10, x10, Operand::UntagSmiAndScale(key, kPointerSizeLog2));
   __ Ldr(x11, MemOperand(x10));
   __ CompareAndBranch(x11, kHoleNanInt64, ne, &fast_double_without_map_check);
   __ JumpIfDictionaryInPrototypeChain(receiver, elements_map, x10, slow);
 
   __ Bind(&fast_double_without_map_check);
   __ StoreNumberToDoubleElements(value,
                                  key,
                                  elements,
@@ skipping 13 matching lines @@
   // Transition the array appropriately depending on the value type.
   __ Ldr(x10, FieldMemOperand(value, HeapObject::kMapOffset));
   __ JumpIfNotRoot(x10, Heap::kHeapNumberMapRootIndex, &non_double_value);
 
   // Value is a double. Transition FAST_SMI_ELEMENTS ->
   // FAST_DOUBLE_ELEMENTS and complete the store.
   __ LoadTransitionedArrayMapConditional(FAST_SMI_ELEMENTS,
                                          FAST_DOUBLE_ELEMENTS,
                                          receiver_map,
                                          x10,
+                                         x11,
                                          slow);
   ASSERT(receiver_map.Is(x3));  // Transition code expects map in x3.
   AllocationSiteMode mode = AllocationSite::GetMode(FAST_SMI_ELEMENTS,
                                                     FAST_DOUBLE_ELEMENTS);
   ElementsTransitionGenerator::GenerateSmiToDouble(masm, mode, slow);
   __ Ldr(elements, FieldMemOperand(receiver, JSObject::kElementsOffset));
   __ B(&fast_double_without_map_check);
 
   __ Bind(&non_double_value);
   // Value is not a double, FAST_SMI_ELEMENTS -> FAST_ELEMENTS.
   __ LoadTransitionedArrayMapConditional(FAST_SMI_ELEMENTS,
                                          FAST_ELEMENTS,
                                          receiver_map,
                                          x10,
+                                         x11,
                                          slow);
   ASSERT(receiver_map.Is(x3));  // Transition code expects map in x3.
   mode = AllocationSite::GetMode(FAST_SMI_ELEMENTS, FAST_ELEMENTS);
   ElementsTransitionGenerator::GenerateMapChangeElementsTransition(masm, mode,
                                                                    slow);
   __ Ldr(elements, FieldMemOperand(receiver, JSObject::kElementsOffset));
   __ B(&finish_store);
 
   __ Bind(&transition_double_elements);
   // Elements are FAST_DOUBLE_ELEMENTS, but value is an Object that's not a
   // HeapNumber. Make sure that the receiver is a Array with FAST_ELEMENTS and
   // transition array from FAST_DOUBLE_ELEMENTS to FAST_ELEMENTS
   __ LoadTransitionedArrayMapConditional(FAST_DOUBLE_ELEMENTS,
                                          FAST_ELEMENTS,
                                          receiver_map,
                                          x10,
+                                         x11,
                                          slow);
   ASSERT(receiver_map.Is(x3));  // Transition code expects map in x3.
   mode = AllocationSite::GetMode(FAST_DOUBLE_ELEMENTS, FAST_ELEMENTS);
   ElementsTransitionGenerator::GenerateDoubleToObject(masm, mode, slow);
   __ Ldr(elements, FieldMemOperand(receiver, JSObject::kElementsOffset));
   __ B(&finish_store);
 }
 
 
 void KeyedStoreIC::GenerateGeneric(MacroAssembler* masm,
-                                   StrictModeFlag strict_mode) {
+                                   StrictMode strict_mode) {
   ASM_LOCATION("KeyedStoreIC::GenerateGeneric");
   // ---------- S t a t e --------------
   //  -- x0     : value
   //  -- x1     : key
   //  -- x2     : receiver
   //  -- lr     : return address
   // -----------------------------------
   Label slow;
   Label array;
   Label fast_object;
@@ skipping 145 matching lines @@
   __ Ret();
 
   // Cache miss: Jump to runtime.
   __ Bind(&miss);
   __ IncrementCounter(counters->store_normal_miss(), 1, x4, x5);
   GenerateMiss(masm);
 }
 
 
 void StoreIC::GenerateRuntimeSetProperty(MacroAssembler* masm,
-                                  StrictModeFlag strict_mode) {
+                                         StrictMode strict_mode) {
   ASM_LOCATION("StoreIC::GenerateRuntimeSetProperty");
   // ----------- S t a t e -------------
   //  -- x0    : value
   //  -- x1    : receiver
   //  -- x2    : name
   //  -- lr    : return address
   // -----------------------------------
 
   __ Push(x1, x2, x0);
 
@@ skipping 110 matching lines @@
     ASSERT(to_patch->Mask(TestBranchMask) == TBNZ);
     // This is JumpIfSmi(smi_reg, branch_imm).
     patcher.tbz(smi_reg, 0, branch_imm);
   }
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64