Revert "ARM64: Use UntagSmi helpers and clean up assertions."

src/arm64/lithium-codegen-arm64.cc

 // Copyright 2013 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/v8.h"
 
 #include "src/arm64/lithium-codegen-arm64.h"
 #include "src/arm64/lithium-gap-resolver-arm64.h"
 #include "src/code-stubs.h"
 #include "src/hydrogen-osr.h"
@@ skipping 3507 matching lines @@
 }
 
 
 MemOperand LCodeGen::PrepareKeyedArrayOperand(Register base,
                                               Register elements,
                                               Register key,
                                               bool key_is_tagged,
                                               ElementsKind elements_kind,
                                               Representation representation,
                                               int base_offset) {
-  STATIC_ASSERT((kSmiValueSize == kWRegSizeInBits) && (kSmiTag == 0));
+  STATIC_ASSERT((kSmiValueSize == 32) && (kSmiShift == 32) && (kSmiTag == 0));
   int element_size_shift = ElementsKindToShiftSize(elements_kind);
 
   // Even though the HLoad/StoreKeyed instructions force the input
   // representation for the key to be an integer, the input gets replaced during
   // bounds check elimination with the index argument to the bounds check, which
   // can be tagged, so that case must be handled here, too.
   if (key_is_tagged) {
     __ Add(base, elements, Operand::UntagSmiAndScale(key, element_size_shift));
     if (representation.IsInteger32()) {
       ASSERT(elements_kind == FAST_SMI_ELEMENTS);
-      // Read or write only the smi payload in the case of fast smi arrays.
+      // Read or write only the most-significant 32 bits in the case of fast smi
+      // arrays.
       return UntagSmiMemOperand(base, base_offset);
     } else {
       return MemOperand(base, base_offset);
     }
   } else {
     // Sign extend key because it could be a 32-bit negative value or contain
     // garbage in the top 32-bits. The address computation happens in 64-bit.
     ASSERT((element_size_shift >= 0) && (element_size_shift <= 4));
     if (representation.IsInteger32()) {
       ASSERT(elements_kind == FAST_SMI_ELEMENTS);
-      // Read or write only the smi payload in the case of fast smi arrays.
+      // Read or write only the most-significant 32 bits in the case of fast smi
+      // arrays.
       __ Add(base, elements, Operand(key, SXTW, element_size_shift));
       return UntagSmiMemOperand(base, base_offset);
     } else {
       __ Add(base, elements, base_offset);
       return MemOperand(base, key, SXTW, element_size_shift);
     }
   }
 }
 
 
@@ skipping 42 matching lines @@
   MemOperand mem_op;
 
   Representation representation = instr->hydrogen()->representation();
   if (instr->key()->IsConstantOperand()) {
     ASSERT(instr->temp() == NULL);
     LConstantOperand* const_operand = LConstantOperand::cast(instr->key());
     int offset = instr->base_offset() +
         ToInteger32(const_operand) * kPointerSize;
     if (representation.IsInteger32()) {
       ASSERT(instr->hydrogen()->elements_kind() == FAST_SMI_ELEMENTS);
-      STATIC_ASSERT((kSmiValueSize == kWRegSizeInBits) && (kSmiTag == 0));
+      STATIC_ASSERT((kSmiValueSize == 32) && (kSmiShift == 32) &&
+                    (kSmiTag == 0));
       mem_op = UntagSmiMemOperand(elements, offset);
     } else {
       mem_op = MemOperand(elements, offset);
     }
   } else {
     Register load_base = ToRegister(instr->temp());
     Register key = ToRegister(instr->key());
     bool key_is_tagged = instr->hydrogen()->key()->representation().IsSmi();
 
     mem_op = PrepareKeyedArrayOperand(load_base, elements, key, key_is_tagged,
@@ skipping 49 matching lines @@
     source = object;
   } else {
     // Load the properties array, using result as a scratch register.
     __ Ldr(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
     source = result;
   }
 
   if (access.representation().IsSmi() &&
       instr->hydrogen()->representation().IsInteger32()) {
     // Read int value directly from upper half of the smi.
-    STATIC_ASSERT((kSmiValueSize == kWRegSizeInBits) && (kSmiTag == 0));
+    STATIC_ASSERT(kSmiValueSize == 32 && kSmiShift == 32 && kSmiTag == 0);
     __ Load(result, UntagSmiFieldMemOperand(source, offset),
             Representation::Integer32());
   } else {
     __ Load(result, FieldMemOperand(source, offset), access.representation());
   }
 }
 
 
 void LCodeGen::DoLoadNamedGeneric(LLoadNamedGeneric* instr) {
   ASSERT(ToRegister(instr->context()).is(cp));
@@ skipping 1582 matching lines @@
 
   Representation representation = instr->hydrogen()->value()->representation();
   if (instr->key()->IsConstantOperand()) {
     LConstantOperand* const_operand = LConstantOperand::cast(instr->key());
     int offset = instr->base_offset() +
         ToInteger32(const_operand) * kPointerSize;
     store_base = elements;
     if (representation.IsInteger32()) {
       ASSERT(instr->hydrogen()->store_mode() == STORE_TO_INITIALIZED_ENTRY);
       ASSERT(instr->hydrogen()->elements_kind() == FAST_SMI_ELEMENTS);
-      STATIC_ASSERT((kSmiValueSize == kWRegSizeInBits) && (kSmiTag == 0));
+      STATIC_ASSERT((kSmiValueSize == 32) && (kSmiShift == 32) &&
+                    (kSmiTag == 0));
       mem_op = UntagSmiMemOperand(store_base, offset);
     } else {
       mem_op = MemOperand(store_base, offset);
     }
   } else {
     store_base = scratch;
     key = ToRegister(instr->key());
     bool key_is_tagged = instr->hydrogen()->key()->representation().IsSmi();
 
     mem_op = PrepareKeyedArrayOperand(store_base, elements, key, key_is_tagged,
@@ skipping 98 matching lines @@
     Register temp0 = ToRegister(instr->temp0());
     __ Ldr(temp0, FieldMemOperand(destination, offset));
     __ AssertSmi(temp0);
     // If destination aliased temp0, restore it to the address calculated
     // earlier.
     if (destination.Is(temp0)) {
       ASSERT(!access.IsInobject());
       __ Ldr(destination, FieldMemOperand(object, JSObject::kPropertiesOffset));
     }
 #endif
-    STATIC_ASSERT((kSmiValueSize == kWRegSizeInBits) && (kSmiTag == 0));
+    STATIC_ASSERT(kSmiValueSize == 32 && kSmiShift == 32 && kSmiTag == 0);
     __ Store(value, UntagSmiFieldMemOperand(destination, offset),
              Representation::Integer32());
   } else {
     __ Store(value, FieldMemOperand(destination, offset), representation);
   }
   if (instr->hydrogen()->NeedsWriteBarrier()) {
     __ RecordWriteField(destination,
                         offset,
                         value,                        // Clobbered.
                         ToRegister(instr->temp1()),   // Clobbered.
@@ skipping 622 matching lines @@
   Handle<ScopeInfo> scope_info = instr->scope_info();
   __ Push(scope_info);
   __ Push(ToRegister(instr->function()));
   CallRuntime(Runtime::kPushBlockContext, 2, instr);
   RecordSafepoint(Safepoint::kNoLazyDeopt);
 }
 
 
 
 } }  // namespace v8::internal