S390:[crankshaft] Sign-ext key before array access

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 1260 matching lines @@
   __ ltr(scratch, scratch);  // use 32 bit version LoadAndTestRR even in 64 bit
   __ bge(&done, Label::kNear);
 
   // If there is no remainder then we are done.
   __ lr(scratch, result);
   __ msr(scratch, divisor);
   __ Cmp32(dividend, scratch);
   __ beq(&done, Label::kNear);
 
   // We performed a truncating division. Correct the result.
-  __ SubP(result, result, Operand(1));
+  __ Sub32(result, result, Operand(1));
   __ bind(&done);
 }
 
 void LCodeGen::DoMultiplyAddD(LMultiplyAddD* instr) {
   DoubleRegister addend = ToDoubleRegister(instr->addend());
   DoubleRegister multiplier = ToDoubleRegister(instr->multiplier());
   DoubleRegister multiplicand = ToDoubleRegister(instr->multiplicand());
   DoubleRegister result = ToDoubleRegister(instr->result());
 
   // Unable to use madbr as the intermediate value is not rounded
@@ skipping 2927 matching lines @@
     LConstantOperand* const_operand = LConstantOperand::cast(instr->key());
     offset += ToInteger32(const_operand) * kPointerSize;
   } else {
     // Even though the HLoadKeyed instruction forces the input
     // representation for the key to be an integer, the input gets replaced
     // during bound check elimination with the index argument to the bounds
     // check, which can be tagged, so that case must be handled here, too.
     if (hinstr->key()->representation().IsSmi()) {
       __ SmiToPtrArrayOffset(scratch, key);
     } else {
-      __ ShiftLeftP(scratch, key, Operand(kPointerSizeLog2));
+      if (instr->hydrogen()->IsDehoisted()) {
+#if V8_TARGET_ARCH_S390X
+        // If array access is dehoisted, the key, being an int32, can contain
+        // a negative value, as needs to be sign-extended to 64-bit for
+        // memory access.
+        __ lgfr(key, key);
+#endif
+        __ ShiftLeftP(scratch, key, Operand(kPointerSizeLog2));
+      } else {
+        // Small optimization to reduce pathlength.  After Bounds Check,
+        // the key is guaranteed to be non-negative.  Leverage RISBG,
+        // which also performs zero-extension.
+        __ risbg(scratch, key, Operand(32 - kPointerSizeLog2),
+                 Operand(63 - kPointerSizeLog2), Operand(kPointerSizeLog2),
+                 true);
+      }
     }
   }
 
   Representation representation = hinstr->value()->representation();
 
 #if V8_TARGET_ARCH_S390X
   // 64-bit Smi optimization
   if (representation.IsInteger32()) {
     DCHECK(hinstr->store_mode() == STORE_TO_INITIALIZED_ENTRY);
     DCHECK(hinstr->elements_kind() == FAST_SMI_ELEMENTS);
@@ skipping 1406 matching lines @@
 }
 
 void LCodeGen::DoStoreFrameContext(LStoreFrameContext* instr) {
   Register context = ToRegister(instr->context());
   __ StoreP(context, MemOperand(fp, StandardFrameConstants::kContextOffset));
 }
 
 #undef __
 }  // namespace internal
 }  // namespace v8