S390: Upstream changes from the past 2 weeks

src/s390/codegen-s390.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/s390/codegen-s390.h"
 
 #if V8_TARGET_ARCH_S390
 
 #include "src/codegen.h"
 #include "src/macro-assembler.h"
@@ skipping 252 matching lines @@
 
 void ElementsTransitionGenerator::GenerateDoubleToObject(
     MacroAssembler* masm, Register receiver, Register key, Register value,
     Register target_map, AllocationSiteMode mode, Label* fail) {
   // Register lr contains the return address.
   Label loop, convert_hole, gc_required, only_change_map;
   Register elements = r6;
   Register array = r8;
   Register length = r7;
   Register scratch = r1;
+  Register scratch3 = r9;
+  Register hole_value = r9;
 
   // Verify input registers don't conflict with locals.
   DCHECK(!AreAliased(receiver, key, value, target_map, elements, array, length,
                      scratch));
 
   if (mode == TRACK_ALLOCATION_SITE) {
     __ JumpIfJSArrayHasAllocationMemento(receiver, elements, fail);
   }
 
   // Check for empty arrays, which only require a map transition and no changes
@@ skipping 25 matching lines @@
   __ AddP(array, Operand(kHeapObjectTag));
 
   // Prepare for conversion loop.
   Register src_elements = elements;
   Register dst_elements = target_map;
   Register dst_end = length;
   Register heap_number_map = scratch;
   __ AddP(src_elements,
           Operand(FixedDoubleArray::kHeaderSize - kHeapObjectTag));
   __ SmiToPtrArrayOffset(length, length);
-  __ LoadRoot(r9, Heap::kTheHoleValueRootIndex);
+  __ LoadRoot(hole_value, Heap::kTheHoleValueRootIndex);
 
   Label initialization_loop, loop_done;
-  __ ShiftRightP(r0, length, Operand(kPointerSizeLog2));
-  __ beq(&loop_done, Label::kNear /*, cr0*/);
+  __ ShiftRightP(scratch, length, Operand(kPointerSizeLog2));
+  __ beq(&loop_done, Label::kNear);
 
   // Allocating heap numbers in the loop below can fail and cause a jump to
   // gc_required. We can't leave a partly initialized FixedArray behind,
   // so pessimistically fill it with holes now.
   __ AddP(dst_elements, array,
           Operand(FixedArray::kHeaderSize - kHeapObjectTag - kPointerSize));
   __ bind(&initialization_loop);
-  __ StoreP(r9, MemOperand(dst_elements, kPointerSize));
+  __ StoreP(hole_value, MemOperand(dst_elements, kPointerSize));
   __ lay(dst_elements, MemOperand(dst_elements, kPointerSize));
-  __ BranchOnCount(r0, &initialization_loop);
+  __ BranchOnCount(scratch, &initialization_loop);
 
   __ AddP(dst_elements, array,
           Operand(FixedArray::kHeaderSize - kHeapObjectTag));
   __ AddP(dst_end, dst_elements, length);
   __ LoadRoot(heap_number_map, Heap::kHeapNumberMapRootIndex);
   // Using offsetted addresses in src_elements to fully take advantage of
   // post-indexing.
   // dst_elements: begin of destination FixedArray element fields, not tagged
   // src_elements: begin of source FixedDoubleArray element fields,
   //               not tagged, +4
   // dst_end: end of destination FixedArray, not tagged
   // array: destination FixedArray
-  // r9: the-hole pointer
+  // hole_value: the-hole pointer
   // heap_number_map: heap number map
   __ b(&loop, Label::kNear);
 
   // Call into runtime if GC is required.
   __ bind(&gc_required);
   __ Pop(target_map, receiver, key, value);
   __ b(fail);
 
   // Replace the-hole NaN with the-hole pointer.
   __ bind(&convert_hole);
-  __ StoreP(r9, MemOperand(dst_elements));
+  __ StoreP(hole_value, MemOperand(dst_elements));
   __ AddP(dst_elements, Operand(kPointerSize));
   __ CmpLogicalP(dst_elements, dst_end);
   __ bge(&loop_done);
 
   __ bind(&loop);
   Register upper_bits = key;
   __ LoadlW(upper_bits, MemOperand(src_elements, Register::kExponentOffset));
   __ AddP(src_elements, Operand(kDoubleSize));
   // upper_bits: current element's upper 32 bit
   // src_elements: address of next element's upper 32 bit
   __ Cmp32(upper_bits, Operand(kHoleNanUpper32));
   __ beq(&convert_hole, Label::kNear);
 
   // Non-hole double, copy value into a heap number.
   Register heap_number = receiver;
   Register scratch2 = value;
-  __ AllocateHeapNumber(heap_number, scratch2, r1, heap_number_map,
+  __ AllocateHeapNumber(heap_number, scratch2, scratch3, heap_number_map,
                         &gc_required);
 // heap_number: new heap number
 #if V8_TARGET_ARCH_S390X
   __ lg(scratch2, MemOperand(src_elements, -kDoubleSize));
   // subtract tag for std
   __ AddP(upper_bits, heap_number, Operand(-kHeapObjectTag));
   __ stg(scratch2, MemOperand(upper_bits, HeapNumber::kValueOffset));
 #else
   __ LoadlW(scratch2,
             MemOperand(src_elements, Register::kMantissaOffset - kDoubleSize));
@@ skipping 216 matching lines @@
   USE(isolate);
   DCHECK(young_sequence_.length() == kNoCodeAgeSequenceLength);
   // Since patcher is a large object, allocate it dynamically when needed,
   // to avoid overloading the stack in stress conditions.
   // DONT_FLUSH is used because the CodeAgingHelper is initialized early in
   // the process, before ARM simulator ICache is setup.
   base::SmartPointer<CodePatcher> patcher(
       new CodePatcher(isolate, young_sequence_.start(),
                       young_sequence_.length(), CodePatcher::DONT_FLUSH));
   PredictableCodeSizeScope scope(patcher->masm(), young_sequence_.length());
-  patcher->masm()->PushFixedFrame(r3);
-  patcher->masm()->la(
-      fp, MemOperand(sp, StandardFrameConstants::kFixedFrameSizeFromFp));
+  patcher->masm()->PushStandardFrame(r3);
 }
 
 #ifdef DEBUG
 bool CodeAgingHelper::IsOld(byte* candidate) const {
   return Assembler::IsNop(Assembler::instr_at(candidate));
 }
 #endif
 
 bool Code::IsYoungSequence(Isolate* isolate, byte* sequence) {
   bool result = isolate->code_aging_helper()->IsYoung(sequence);
@@ skipping 43 matching lines @@
       //       (kNoCodeAgeSequenceLength - kCodeAgingSequenceLength) bytes.
       patcher.masm()->nop();  // 2-byte nops().
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_S390