S390: Used RISBG in MacroAssembler::IndexToArrayOffset to improve performance.

src/crankshaft/s390/lithium-codegen-s390.cc

 // Copyright 2014 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/crankshaft/s390/lithium-codegen-s390.h"
 
 #include "src/base/bits.h"
 #include "src/code-factory.h"
 #include "src/code-stubs.h"
@@ skipping 2852 matching lines @@
   if (key_is_constant) {
     constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
     if (constant_key & 0xF0000000) {
       Abort(kArrayIndexConstantValueTooBig);
     }
   } else {
     key = ToRegister(instr->key());
   }
   int element_size_shift = ElementsKindToShiftSize(elements_kind);
   bool key_is_smi = instr->hydrogen()->key()->representation().IsSmi();
+  bool keyMaybeNegative = instr->hydrogen()->IsDehoisted();
   int base_offset = instr->base_offset();
   bool use_scratch = false;
 
   if (elements_kind == FLOAT32_ELEMENTS || elements_kind == FLOAT64_ELEMENTS) {
     DoubleRegister result = ToDoubleRegister(instr->result());
     if (key_is_constant) {
       base_offset += constant_key << element_size_shift;
       if (!is_int20(base_offset)) {
         __ mov(scratch0(), Operand(base_offset));
         base_offset = 0;
         use_scratch = true;
       }
     } else {
-      __ IndexToArrayOffset(scratch0(), key, element_size_shift, key_is_smi);
+      __ IndexToArrayOffset(scratch0(), key, element_size_shift, key_is_smi,
+                            keyMaybeNegative);
       use_scratch = true;
     }
     if (elements_kind == FLOAT32_ELEMENTS) {
       if (!use_scratch) {
         __ ldeb(result, MemOperand(external_pointer, base_offset));
       } else {
         __ ldeb(result, MemOperand(scratch0(), external_pointer, base_offset));
       }
     } else {  // i.e. elements_kind == EXTERNAL_DOUBLE_ELEMENTS
       if (!use_scratch) {
         __ ld(result, MemOperand(external_pointer, base_offset));
       } else {
         __ ld(result, MemOperand(scratch0(), external_pointer, base_offset));
       }
     }
   } else {
     Register result = ToRegister(instr->result());
     MemOperand mem_operand =
         PrepareKeyedOperand(key, external_pointer, key_is_constant, key_is_smi,
-                            constant_key, element_size_shift, base_offset);
+                            constant_key, element_size_shift, base_offset,
+                            keyMaybeNegative);
     switch (elements_kind) {
       case INT8_ELEMENTS:
         __ LoadB(result, mem_operand);
         break;
       case UINT8_ELEMENTS:
       case UINT8_CLAMPED_ELEMENTS:
         __ LoadlB(result, mem_operand);
         break;
       case INT16_ELEMENTS:
         __ LoadHalfWordP(result, mem_operand);
@@ skipping 33 matching lines @@
 
 void LCodeGen::DoLoadKeyedFixedDoubleArray(LLoadKeyed* instr) {
   Register elements = ToRegister(instr->elements());
   bool key_is_constant = instr->key()->IsConstantOperand();
   Register key = no_reg;
   DoubleRegister result = ToDoubleRegister(instr->result());
   Register scratch = scratch0();
 
   int element_size_shift = ElementsKindToShiftSize(FAST_DOUBLE_ELEMENTS);
   bool key_is_smi = instr->hydrogen()->key()->representation().IsSmi();
+  bool keyMaybeNegative = instr->hydrogen()->IsDehoisted();
   int constant_key = 0;
   if (key_is_constant) {
     constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
     if (constant_key & 0xF0000000) {
       Abort(kArrayIndexConstantValueTooBig);
     }
   } else {
     key = ToRegister(instr->key());
   }
 
   bool use_scratch = false;
   intptr_t base_offset = instr->base_offset() + constant_key * kDoubleSize;
   if (!key_is_constant) {
     use_scratch = true;
-    __ IndexToArrayOffset(scratch, key, element_size_shift, key_is_smi);
+    __ IndexToArrayOffset(scratch, key, element_size_shift, key_is_smi,
+                          keyMaybeNegative);
   }
 
   // Memory references support up to 20-bits signed displacement in RXY form
   // Include Register::kExponentOffset in check, so we are guaranteed not to
   // overflow displacement later.
   if (!is_int20(base_offset + Register::kExponentOffset)) {
     use_scratch = true;
     if (key_is_constant) {
       __ mov(scratch, Operand(base_offset));
     } else {
@@ skipping 101 matching lines @@
     DoLoadKeyedFixedDoubleArray(instr);
   } else {
     DoLoadKeyedFixedArray(instr);
   }
 }
 
 MemOperand LCodeGen::PrepareKeyedOperand(Register key, Register base,
                                          bool key_is_constant, bool key_is_smi,
                                          int constant_key,
                                          int element_size_shift,
-                                         int base_offset) {
+                                         int base_offset,
+                                         bool keyMaybeNegative) {
   Register scratch = scratch0();
 
   if (key_is_constant) {
     int offset = (base_offset + (constant_key << element_size_shift));
     if (!is_int20(offset)) {
       __ mov(scratch, Operand(offset));
       return MemOperand(base, scratch);
     } else {
       return MemOperand(base,
                         (constant_key << element_size_shift) + base_offset);
     }
   }
 
   bool needs_shift =
       (element_size_shift != (key_is_smi ? kSmiTagSize + kSmiShiftSize : 0));
 
   if (needs_shift) {
-    __ IndexToArrayOffset(scratch, key, element_size_shift, key_is_smi);
+    __ IndexToArrayOffset(scratch, key, element_size_shift, key_is_smi,
+                          keyMaybeNegative);
   } else {
     scratch = key;
   }
 
   if (!is_int20(base_offset)) {
     __ AddP(scratch, Operand(base_offset));
     base_offset = 0;
   }
   return MemOperand(scratch, base, base_offset);
 }
@@ skipping 918 matching lines @@
   if (key_is_constant) {
     constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
     if (constant_key & 0xF0000000) {
       Abort(kArrayIndexConstantValueTooBig);
     }
   } else {
     key = ToRegister(instr->key());
   }
   int element_size_shift = ElementsKindToShiftSize(elements_kind);
   bool key_is_smi = instr->hydrogen()->key()->representation().IsSmi();
+  bool keyMaybeNegative = instr->hydrogen()->IsDehoisted();
   int base_offset = instr->base_offset();
 
   if (elements_kind == FLOAT32_ELEMENTS || elements_kind == FLOAT64_ELEMENTS) {
     Register address = scratch0();
     DoubleRegister value(ToDoubleRegister(instr->value()));
     if (key_is_constant) {
       if (constant_key != 0) {
         base_offset += constant_key << element_size_shift;
         if (!is_int20(base_offset)) {
           __ mov(address, Operand(base_offset));
           __ AddP(address, external_pointer);
         } else {
           __ AddP(address, external_pointer, Operand(base_offset));
         }
         base_offset = 0;
       } else {
         address = external_pointer;
       }
     } else {
-      __ IndexToArrayOffset(address, key, element_size_shift, key_is_smi);
+      __ IndexToArrayOffset(address, key, element_size_shift, key_is_smi,
+                            keyMaybeNegative);
       __ AddP(address, external_pointer);
     }
     if (elements_kind == FLOAT32_ELEMENTS) {
       __ ledbr(double_scratch0(), value);
       __ StoreFloat32(double_scratch0(), MemOperand(address, base_offset));
     } else {  // Storing doubles, not floats.
       __ StoreDouble(value, MemOperand(address, base_offset));
     }
   } else {
     Register value(ToRegister(instr->value()));
     MemOperand mem_operand =
         PrepareKeyedOperand(key, external_pointer, key_is_constant, key_is_smi,
-                            constant_key, element_size_shift, base_offset);
+                            constant_key, element_size_shift, base_offset,
+                            keyMaybeNegative);
     switch (elements_kind) {
       case UINT8_ELEMENTS:
       case UINT8_CLAMPED_ELEMENTS:
       case INT8_ELEMENTS:
         if (key_is_constant) {
           __ StoreByte(value, mem_operand, r0);
         } else {
           __ StoreByte(value, mem_operand);
         }
         break;
@@ skipping 47 matching lines @@
   if (key_is_constant) {
     constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
     if (constant_key & 0xF0000000) {
       Abort(kArrayIndexConstantValueTooBig);
     }
   } else {
     key = ToRegister(instr->key());
   }
   int element_size_shift = ElementsKindToShiftSize(FAST_DOUBLE_ELEMENTS);
   bool key_is_smi = instr->hydrogen()->key()->representation().IsSmi();
+  bool keyMaybeNegative = instr->hydrogen()->IsDehoisted();
   int base_offset = instr->base_offset() + constant_key * kDoubleSize;
   bool use_scratch = false;
   intptr_t address_offset = base_offset;
 
   if (key_is_constant) {
     // Memory references support up to 20-bits signed displacement in RXY form
     if (!is_int20((address_offset))) {
       __ mov(scratch, Operand(address_offset));
       address_offset = 0;
       use_scratch = true;
     }
   } else {
     use_scratch = true;
-    __ IndexToArrayOffset(scratch, key, element_size_shift, key_is_smi);
+    __ IndexToArrayOffset(scratch, key, element_size_shift, key_is_smi,
+                          keyMaybeNegative);
     // Memory references support up to 20-bits signed displacement in RXY form
     if (!is_int20((address_offset))) {
       __ AddP(scratch, Operand(address_offset));
       address_offset = 0;
     }
   }
 
   if (instr->NeedsCanonicalization()) {
     // Turn potential sNaN value into qNaN.
     __ CanonicalizeNaN(double_scratch, value);
@@ skipping 1514 matching lines @@
   __ LoadP(result,
            FieldMemOperand(scratch, FixedArray::kHeaderSize - kPointerSize));
   __ bind(deferred->exit());
   __ bind(&done);
 }
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8