A64: Synchronize with r15358.

src/a64/lithium-codegen-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 59 matching lines @@
  public:
   BranchOnCondition(LCodeGen* codegen, Condition cond)
     : BranchGenerator(codegen),
       cond_(cond) { }
 
   virtual void Emit(Label* label) const {
     __ B(cond_, label);
   }
 
   virtual void EmitInverted(Label* label) const {
-    __ B(InvertCondition(cond_), label);
+    if (cond_ != al) {
+      __ B(InvertCondition(cond_), label);
+    }
   }
 
  private:
   Condition cond_;
 };
 
 
 // Emit code to compare lhs and rhs and branch if the condition holds.
 // This uses MacroAssembler's CompareAndBranch function so it will handle
 // converting the comparison to Cbz/Cbnz if the right-hand side is 0.
@@ skipping 69 matching lines @@
     }
   }
 
  private:
   Condition cond_;
   const Register& value_;
   uint64_t mask_;
 };
 
 
+// Test the input and branch if it is non-zero and not a NaN.
+class BranchIfNonZeroNumber : public BranchGenerator {
+ public:
+  BranchIfNonZeroNumber(LCodeGen* codegen, const FPRegister& value,
+                        const FPRegister& scratch)
+    : BranchGenerator(codegen), value_(value), scratch_(scratch) { }
+
+  virtual void Emit(Label* label) const {
+    __ Fabs(scratch_, value_);
+    // Compare with 0.0. Because scratch_ is positive, the result can be one of
+    // nZCv (equal), nzCv (greater) or nzCV (unordered).
+    __ Fcmp(scratch_, 0.0);
+    __ B(gt, label);
+  }
+
+  virtual void EmitInverted(Label* label) const {
+    __ Fabs(scratch_, value_);
+    __ Fcmp(scratch_, 0.0);
+    __ B(le, label);
+  }
+
+ private:
+  const FPRegister& value_;
+  const FPRegister& scratch_;
+};
+
+
 void LCodeGen::WriteTranslation(LEnvironment* environment,
                                 Translation* translation) {
   if (environment == NULL) return;
 
   // The translation includes one command per value in the environment.
   int translation_size = environment->translation_size();
   // The output frame height does not include the parameters.
   int height = translation_size - environment->parameter_count();
 
   WriteTranslation(environment->outer(), translation);
@@ skipping 25 matching lines @@
       break;
     case ARGUMENTS_ADAPTOR:
       translation->BeginArgumentsAdaptorFrame(closure_id, translation_size);
       break;
     default:
       UNREACHABLE();
   }
 
   for (int i = 0; i < translation_size; ++i) {
     LOperand* value = environment->values()->at(i);
-    // spilled_registers_ and spilled_double_registers_ are either
-    // both NULL or both set.
-    if ((environment->spilled_registers() != NULL) && (value != NULL)) {
-      if (value->IsRegister() &&
-          (environment->spilled_registers()[value->index()] != NULL)) {
-        translation->MarkDuplicate();
-        AddToTranslation(translation,
-                         environment->spilled_registers()[value->index()],
-                         environment->HasTaggedValueAt(i),
-                         environment->HasUint32ValueAt(i));
-      } else if (
-          value->IsDoubleRegister() &&
-          (environment->spilled_double_registers()[value->index()] != NULL)) {
-        translation->MarkDuplicate();
-        AddToTranslation(
-            translation,
-            environment->spilled_double_registers()[value->index()],
-            false,
-            false);
-      }
-    }
 
     // TODO(mstarzinger): Introduce marker operands to indicate that this value
     // is not present and must be reconstructed from the deoptimizer. Currently
     // this is only used for the arguments object.
     if (value == NULL) {
       int arguments_count = environment->values()->length() - translation_size;
       translation->BeginArgumentsObject(arguments_count);
       for (int i = 0; i < arguments_count; ++i) {
         LOperand* value = environment->values()->at(translation_size + i);
-        ASSERT(environment->spilled_registers() == NULL ||
-               !value->IsRegister() ||
-               environment->spilled_registers()[value->index()] == NULL);
-        ASSERT(environment->spilled_registers() == NULL ||
-               !value->IsDoubleRegister() ||
-               environment->spilled_double_registers()[value->index()] == NULL);
         AddToTranslation(translation,
                          value,
                          environment->HasTaggedValueAt(translation_size + i),
                          environment->HasUint32ValueAt(translation_size + i));
       }
       continue;
     }
 
     AddToTranslation(translation,
                      value,
@@ skipping 113 matching lines @@
   CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
   __ Ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
 }
 
 
 void LCodeGen::DoCallNew(LCallNew* instr) {
   ASSERT(instr->IsMarkedAsCall());
   ASSERT(ToRegister(instr->constructor()).is(x1));
 
   __ Mov(x0, instr->arity());
-  if (FLAG_optimize_constructed_arrays) {
-    // No cell in x2 for construct type feedback in optimized code.
-    Handle<Object> undefined_value(isolate()->heap()->undefined_value(),
-                                   isolate());
-    __ Mov(x2, Operand(undefined_value));
-  }
+  // No cell in x2 for construct type feedback in optimized code.
+  Handle<Object> undefined_value(isolate()->factory()->undefined_value());
+  __ Mov(x2, Operand(undefined_value));
 
   CallConstructStub stub(NO_CALL_FUNCTION_FLAGS);
   CallCode(stub.GetCode(isolate()), RelocInfo::CONSTRUCT_CALL, instr);
 
   ASSERT(ToRegister(instr->result()).is(x0));
 }
 
 
 void LCodeGen::DoCallNewArray(LCallNewArray* instr) {
   ASSERT(instr->IsMarkedAsCall());
   ASSERT(ToRegister(instr->constructor()).is(x1));
-  ASSERT(FLAG_optimize_constructed_arrays);
 
   __ Mov(x0, Operand(instr->arity()));
   __ Mov(x2, Operand(instr->hydrogen()->property_cell()));
 
   ElementsKind kind = instr->hydrogen()->elements_kind();
   bool disable_allocation_sites =
       (AllocationSiteInfo::GetMode(kind) == TRACK_ALLOCATION_SITE);
 
   if (instr->arity() == 0) {
     ArrayNoArgumentConstructorStub stub(kind, disable_allocation_sites);
@@ skipping 106 matching lines @@
 
 void LCodeGen::RecordSafepointWithRegisters(LPointerMap* pointers,
                                             int arguments,
                                             Safepoint::DeoptMode deopt_mode) {
   RecordSafepoint(
       pointers, Safepoint::kWithRegisters, arguments, deopt_mode);
 }
 
 
 bool LCodeGen::GenerateCode() {
-  HPhase phase("Z_Code generation", chunk());
+  LPhase phase("Z_Code generation", chunk());
   ASSERT(is_unused());
   status_ = GENERATING;
 
   // Open a frame scope to indicate that there is a frame on the stack.  The
   // NONE indicates that the scope shouldn't actually generate code to set up
   // the frame (that is done in GeneratePrologue).
   FrameScope frame_scope(masm_, StackFrame::NONE);
 
   return GeneratePrologue() &&
       GenerateBody() &&
@@ skipping 218 matching lines @@
 
 
 void LCodeGen::FinishCode(Handle<Code> code) {
   ASSERT(is_done());
   code->set_stack_slots(GetStackSlotCount());
   code->set_safepoint_table_offset(safepoints_.GetCodeOffset());
   if (FLAG_weak_embedded_maps_in_optimized_code) {
     RegisterDependentCodeForEmbeddedMaps(code);
   }
   PopulateDeoptimizationData(code);
-  info()->CommitDependentMaps(code);
+  info()->CommitDependencies(code);
 }
 
 
 void LCodeGen::Abort(const char* reason) {
   info()->set_bailout_reason(reason);
   status_ = ABORTED;
 }
 
 
 void LCodeGen::Comment(const char* format, ...) {
@@ skipping 417 matching lines @@
 template<class InstrType>
 void LCodeGen::EmitTestAndBranch(InstrType instr,
                                  Condition condition,
                                  const Register& value,
                                  uint64_t mask) {
   TestAndBranch branch(this, condition, value, mask);
   EmitBranchGeneric(instr, branch);
 }
 
 
+template<class InstrType>
+void LCodeGen::EmitBranchIfNonZeroNumber(InstrType instr,
+                                         const FPRegister& value,
+                                         const FPRegister& scratch) {
+  BranchIfNonZeroNumber branch(this, value, scratch);
+  EmitBranchGeneric(instr, branch);
+}
+
+
 void LCodeGen::DoGap(LGap* gap) {
   for (int i = LGap::FIRST_INNER_POSITION;
        i <= LGap::LAST_INNER_POSITION;
        i++) {
     LGap::InnerPosition inner_pos = static_cast<LGap::InnerPosition>(i);
     LParallelMove* move = gap->GetParallelMove(inner_pos);
     if (move != NULL) {
       resolver_.Resolve(move);
     }
   }
@@ skipping 107 matching lines @@
     CallRuntimeFromDeferred(Runtime::kAllocateInOldPointerSpace, 1, instr);
   } else if (instr->hydrogen()->CanAllocateInOldDataSpace()) {
     CallRuntimeFromDeferred(Runtime::kAllocateInOldDataSpace, 1, instr);
   } else {
     CallRuntimeFromDeferred(Runtime::kAllocateInNewSpace, 1, instr);
   }
   __ StoreToSafepointRegisterSlot(x0, result);
 }
 
 
+void LCodeGen::DoAllocateObject(LAllocateObject* instr) {
+  class DeferredAllocateObject: public LDeferredCode {
+   public:
+    DeferredAllocateObject(LCodeGen* codegen, LAllocateObject* instr)
+        : LDeferredCode(codegen), instr_(instr) { }
+    virtual void Generate() { codegen()->DoDeferredAllocateObject(instr_); }
+    virtual LInstruction* instr() { return instr_; }
+   private:
+    LAllocateObject* instr_;
+  };
+
+  DeferredAllocateObject* deferred =
+      new(zone()) DeferredAllocateObject(this, instr);
+
+  Register result = ToRegister(instr->result());
+  Register scratch1 = ToRegister(instr->temp1());
+  Register scratch2 = ToRegister(instr->temp2());
+  Handle<JSFunction> constructor = instr->hydrogen()->constructor();
+  Handle<Map> initial_map = instr->hydrogen()->constructor_initial_map();
+  int instance_size = initial_map->instance_size();
+
+  ASSERT(initial_map->pre_allocated_property_fields() +
+         initial_map->unused_property_fields() -
+         initial_map->inobject_properties() == 0);
+
+  __ Allocate(instance_size, result, scratch1, scratch2, deferred->entry(),
+              TAG_OBJECT);
+
+  __ Bind(deferred->exit());
+  if (FLAG_debug_code) {
+    Label is_in_new_space;
+    __ JumpIfInNewSpace(result, &is_in_new_space);
+    __ Abort("Allocated object is not in new-space");
+    __ Bind(&is_in_new_space);
+  }
+
+  // Load the initial map.
+  Register map = scratch1;
+  __ LoadHeapObject(map, constructor);
+  __ Ldr(map, FieldMemOperand(map, JSFunction::kPrototypeOrInitialMapOffset));
+
+  // Initialize map and field of the newly allocated object.
+  ASSERT(initial_map->instance_type() == JS_OBJECT_TYPE);
+  __ Str(map, FieldMemOperand(result, JSObject::kMapOffset));
+
+  Register empty_array = scratch1;
+  __ LoadRoot(empty_array, Heap::kEmptyFixedArrayRootIndex);
+  __ Str(empty_array, FieldMemOperand(result, JSObject::kElementsOffset));
+  __ Str(empty_array, FieldMemOperand(result, JSObject::kPropertiesOffset));
+
+  if (initial_map->inobject_properties() != 0) {
+    Register undef = scratch1;
+    __ LoadRoot(undef, Heap::kUndefinedValueRootIndex);
+    for (int i = 0; i < initial_map->inobject_properties(); i++) {
+      int property_offset = JSObject::kHeaderSize + i * kPointerSize;
+      __ Str(undef, FieldMemOperand(result, property_offset));
+    }
+  }
+}
+
+
+void LCodeGen::DoDeferredAllocateObject(LAllocateObject* instr) {
+  Register result = ToRegister(instr->result());
+  Handle<Map> initial_map = instr->hydrogen()->constructor_initial_map();
+  int instance_size = initial_map->instance_size();
+
+
+  // TODO(3095996): Get rid of this. For now, we need to make the
+  // result register contain a valid pointer because it is already
+  // contained in the register pointer map.
+  __ Mov(result, 0);
+
+  PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
+  __ Mov(x0, Operand(Smi::FromInt(instance_size)));
+  __ Push(x0);
+  CallRuntimeFromDeferred(Runtime::kAllocateInNewSpace, 1, instr);
+  __ StoreToSafepointRegisterSlot(x0, result);
+}
+
+
 void LCodeGen::DoApplyArguments(LApplyArguments* instr) {
   Register receiver = ToRegister(instr->receiver());
   Register function = ToRegister(instr->function());
   Register length = ToRegister(instr->length());
   Register elements = ToRegister(instr->elements());
   Register scratch = x5;
   ASSERT(receiver.Is(x0));  // Used for parameter count.
   ASSERT(function.Is(x1));  // Required by InvokeFunction.
   ASSERT(ToRegister(instr->result()).Is(x0));
   ASSERT(instr->IsMarkedAsCall());
@@ skipping 187 matching lines @@
 
   if (r.IsInteger32()) {
     ASSERT(!info()->IsStub());
     EmitCompareAndBranch(instr, ne, ToRegister32(instr->value()), 0);
   } else if (r.IsSmi()) {
     ASSERT(!info()->IsStub());
     STATIC_ASSERT(kSmiTag == 0);
     EmitCompareAndBranch(instr, ne, ToRegister(instr->value()), 0);
   } else if (r.IsDouble()) {
     DoubleRegister value = ToDoubleRegister(instr->value());
-    __ Fcmp(value, 0.0);
-    // If we got a NaN jump to the false branch.
-    __ B(vs, false_label);
-    EmitBranch(instr, ne);
+    // Test the double value. Zero and NaN are false.
+    EmitBranchIfNonZeroNumber(instr, value, double_scratch());
   } else {
     ASSERT(r.IsTagged());
     Register value = ToRegister(instr->value());
     HType type = instr->hydrogen()->value()->type();
 
     if (type.IsBoolean()) {
       ASSERT(!info()->IsStub());
       __ CompareRoot(value, Heap::kTrueValueRootIndex);
       EmitBranch(instr, eq);
     } else if (type.IsSmi()) {
       ASSERT(!info()->IsStub());
       EmitCompareAndBranch(instr, ne, value, Operand(Smi::FromInt(0)));
+    } else if (type.IsJSArray()) {
+      ASSERT(!info()->IsStub());
+      EmitBranch(instr, al);
+    } else if (type.IsHeapNumber()) {
+      ASSERT(!info()->IsStub());
+      __ Ldr(double_scratch(), FieldMemOperand(value,
+                                               HeapNumber::kValueOffset));
+      // Test the double value. Zero and NaN are false.
+      EmitBranchIfNonZeroNumber(instr, double_scratch(), double_scratch());
+    } else if (type.IsString()) {
+      ASSERT(!info()->IsStub());
+      Register temp = ToRegister(instr->temp1());
+      __ Ldr(temp, FieldMemOperand(value, String::kLengthOffset));
+      EmitCompareAndBranch(instr, ne, temp, 0);
     } else {
       ToBooleanStub::Types expected = instr->hydrogen()->expected_input_types();
       // Avoid deopts in the case where we've never executed this path before.
-      if (expected.IsEmpty()) expected = ToBooleanStub::all_types();
+      if (expected.IsEmpty()) expected = ToBooleanStub::Types::Generic();
 
       if (expected.Contains(ToBooleanStub::UNDEFINED)) {
         // undefined -> false.
         __ JumpIfRoot(
             value, Heap::kUndefinedValueRootIndex, false_label);
       }
 
       if (expected.Contains(ToBooleanStub::BOOLEAN)) {
         // Boolean -> its value.
         __ JumpIfRoot(
@@ skipping 66 matching lines @@
         __ Ldr(double_scratch(),
                FieldMemOperand(value, HeapNumber::kValueOffset));
         __ Fcmp(double_scratch(), 0.0);
         // If we got a NaN (overflow bit is set), jump to the false branch.
         __ B(vs, false_label);
         __ B(eq, false_label);
         __ B(true_label);
         __ Bind(&not_heap_number);
       }
 
-      // We've seen something for the first time -> deopt.
-      Deoptimize(instr->environment());
+      if (!expected.IsGeneric()) {
+        // We've seen something for the first time -> deopt.
+        // This can only happen if we are not generic already.
+        Deoptimize(instr->environment());
+      }
     }
   }
 }
 
 
 void LCodeGen::CallKnownFunction(Handle<JSFunction> function,
                                  int formal_parameter_count,
                                  int arity,
                                  LInstruction* instr,
                                  CallKind call_kind,
@@ skipping 178 matching lines @@
   }
 
   // If we didn't match a map, deoptimize.
   Deoptimize(instr->environment());
 
   __ Bind(&success);
 }
 
 
 void LCodeGen::DoCheckNonSmi(LCheckNonSmi* instr) {
-  // TODO(all): Depending of how we chose to implement the deopt, if we could
-  // guarantee that we have a deopt handler reachable by a tbz instruction,
-  // we could use tbz here and produce less code to support this instruction.
-  DeoptimizeIfSmi(ToRegister(instr->value()), instr->environment());
+  if (!instr->hydrogen()->value()->IsHeapObject()) {
+    // TODO(all): Depending of how we chose to implement the deopt, if we could
+    // guarantee that we have a deopt handler reachable by a tbz instruction,
+    // we could use tbz here and produce less code to support this instruction.
+    DeoptimizeIfSmi(ToRegister(instr->value()), instr->environment());
+  }
 }
 
 
 void LCodeGen::DoCheckPrototypeMaps(LCheckPrototypeMaps* instr) {
   ZoneList<Handle<JSObject> >* prototypes = instr->prototypes();
   ZoneList<Handle<Map> >* maps = instr->maps();
   ASSERT(prototypes->length() == maps->length());
 
   if (!instr->hydrogen()->CanOmitPrototypeChecks()) {
     // TODO(jbramley): The temp registers are only needed in this case.
@@ skipping 734 matching lines @@
   for (int i = current_block_ + 1; i < graph()->blocks()->length(); ++i) {
     if (!chunk_->GetLabel(i)->HasReplacement()) return i;
   }
   return -1;
 }
 
 
 void LCodeGen::EmitGoto(int block) {
   // Do not emit jump if we are emitting a goto to the next block.
   if (!IsNextEmittedBlock(block)) {
-    __ B(chunk_->GetAssemblyLabel(chunk_->LookupDestination(block)));
+    __ B(chunk_->GetAssemblyLabel(LookupDestination(block)));
   }
 }
 
 
 void LCodeGen::DoGoto(LGoto* instr) {
   EmitGoto(instr->block_id());
 }
 
 
 // HHasInstanceTypeAndBranch instruction is built with an interval of type
@@ skipping 27 matching lines @@
   if (from == FIRST_TYPE) return ls;
   UNREACHABLE();
   return eq;
 }
 
 
 void LCodeGen::DoHasInstanceTypeAndBranch(LHasInstanceTypeAndBranch* instr) {
   Register input = ToRegister(instr->value());
   Register scratch = ToRegister(instr->temp());
 
-  // TODO(all): When we'll have rebased, we can avoid the smi check if the
-  // input is known to be a HeapObject.
-  __ JumpIfSmi(input, instr->FalseLabel(chunk_));
+  if (!instr->hydrogen()->value()->IsHeapObject()) {
+    __ JumpIfSmi(input, instr->FalseLabel(chunk_));
+  }
   __ CompareObjectType(input, scratch, scratch, TestType(instr->hydrogen()));
   EmitBranch(instr, BranchCondition(instr->hydrogen()));
 }
 
 
 void LCodeGen::DoIn(LIn* instr) {
   Register obj = ToRegister(instr->object());
   Register key = ToRegister(instr->key());
   __ Push(key, obj);
   ASSERT(instr->HasPointerMap());
@@ skipping 215 matching lines @@
   __ IsInstanceJSObjectType(map, scratch, NULL);
   // Flags have been updated by IsInstanceJSObjectType. We can now test the
   // flags for "le" condition to check if the object's type is a valid
   // JS object type.
   EmitBranch(instr, le);
 }
 
 
 Condition LCodeGen::EmitIsString(Register input,
                                  Register temp1,
-                                 Label* is_not_string) {
-  __ JumpIfSmi(input, is_not_string);
+                                 Label* is_not_string,
+                                 SmiCheck check_needed = INLINE_SMI_CHECK) {
+  if (check_needed == INLINE_SMI_CHECK) {
+    __ JumpIfSmi(input, is_not_string);
+  }
   __ CompareObjectType(input, temp1, temp1, FIRST_NONSTRING_TYPE);
 
   return lt;
 }
 
 
 void LCodeGen::DoIsStringAndBranch(LIsStringAndBranch* instr) {
   Register val = ToRegister(instr->value());
   Register scratch = ToRegister(instr->temp());
 
-  Condition true_cond = EmitIsString(val, scratch, instr->FalseLabel(chunk_));
+  SmiCheck check_needed =
+      instr->hydrogen()->value()->IsHeapObject()
+          ? OMIT_SMI_CHECK : INLINE_SMI_CHECK;
+  Condition true_cond =
+      EmitIsString(val, scratch, instr->FalseLabel(chunk_), check_needed);
 
   EmitBranch(instr, true_cond);
 }
 
 
 void LCodeGen::DoIsSmiAndBranch(LIsSmiAndBranch* instr) {
   Register value = ToRegister(instr->value());
   STATIC_ASSERT(kSmiTag == 0);
   EmitTestAndBranch(instr, eq, value, kSmiTagMask);
 }
 
 
 void LCodeGen::DoIsUndetectableAndBranch(LIsUndetectableAndBranch* instr) {
   Register input = ToRegister(instr->value());
   Register temp = ToRegister(instr->temp());
 
-  __ JumpIfSmi(input, instr->FalseLabel(chunk_));
+  if (!instr->hydrogen()->value()->IsHeapObject()) {
+    __ JumpIfSmi(input, instr->FalseLabel(chunk_));
+  }
   __ Ldr(temp, FieldMemOperand(input, HeapObject::kMapOffset));
   __ Ldrb(temp, FieldMemOperand(temp, Map::kBitFieldOffset));
 
-  // TODO(jbramley): Find a way to use Tbz here.
-  __ Tst(temp, 1 << Map::kIsUndetectable);
-  EmitBranch(instr, ne);
+  EmitTestAndBranch(instr, ne, temp, 1 << Map::kIsUndetectable);
 }
 
 
 static const char* LabelType(LLabel* label) {
   if (label->is_loop_header()) return " (loop header)";
   if (label->is_osr_entry()) return " (OSR entry)";
   return "";
 }
 
 
@@ skipping 1535 matching lines @@
     if (instr->hydrogen()->DeoptimizesOnHole()) {
       DeoptimizeIfRoot(scratch, Heap::kTheHoleValueRootIndex,
                        instr->environment());
     } else {
       __ JumpIfNotRoot(scratch, Heap::kTheHoleValueRootIndex, &skip_assignment);
     }
   }
 
   __ Str(value, target);
   if (instr->hydrogen()->NeedsWriteBarrier()) {
-    HType type = instr->hydrogen()->value()->type();
     SmiCheck check_needed =
-        type.IsHeapObject() ? OMIT_SMI_CHECK : INLINE_SMI_CHECK;
+        instr->hydrogen()->value()->IsHeapObject()
+            ? OMIT_SMI_CHECK : INLINE_SMI_CHECK;
     __ RecordWriteContextSlot(context,
                               target.offset(),
                               value,
                               scratch,
                               GetLinkRegisterState(),
                               kSaveFPRegs,
                               EMIT_REMEMBERED_SET,
                               check_needed);
   }
   __ Bind(&skip_assignment);
@@ skipping 149 matching lines @@
   } else {
     key = ToRegister(instr->key());
     bool key_is_tagged = instr->hydrogen()->key()->representation().IsSmi();
     CalcKeyedArrayBaseRegister(store_base, elements, key, key_is_tagged,
                                instr->hydrogen()->elements_kind());
     offset = FixedArray::OffsetOfElementAt(instr->additional_index());
   }
   __ Str(value, FieldMemOperand(store_base, offset));
 
   if (instr->hydrogen()->NeedsWriteBarrier()) {
-    HType type = instr->hydrogen()->value()->type();
-    SmiCheck check_needed = type.IsHeapObject()
-                              ? OMIT_SMI_CHECK
-                              : INLINE_SMI_CHECK;
+    SmiCheck check_needed =
+        instr->hydrogen()->value()->IsHeapObject()
+            ? OMIT_SMI_CHECK : INLINE_SMI_CHECK;
     // Compute address of modified element and store it into key register.
     __ Add(key, store_base, offset - kHeapObjectTag);
     __ RecordWrite(elements, key, value, GetLinkRegisterState(), kSaveFPRegs,
                    EMIT_REMEMBERED_SET, check_needed);
   }
 }
 
 
 void LCodeGen::DoStoreKeyedGeneric(LStoreKeyedGeneric* instr) {
   ASSERT(ToRegister(instr->object()).Is(x2));
@@ skipping 47 matching lines @@
                           temp1,
                           GetLinkRegisterState(),
                           kSaveFPRegs,
                           OMIT_REMEMBERED_SET,
                           OMIT_SMI_CHECK);
     }
   }
 
   // Do the store.
   Register value = ToRegister(instr->value());
-  HType type = instr->hydrogen()->value()->type();
   SmiCheck check_needed =
-      type.IsHeapObject() ? OMIT_SMI_CHECK : INLINE_SMI_CHECK;
+      instr->hydrogen()->value()->IsHeapObject()
+          ? OMIT_SMI_CHECK : INLINE_SMI_CHECK;
   if (access.IsInobject()) {
     __ Str(value, FieldMemOperand(object, offset));
     if (instr->hydrogen()->NeedsWriteBarrier()) {
       // Update the write barrier for the object for in-object properties.
       __ RecordWriteField(object,
                           offset,
                           value,      // Clobbered.
                           temp0,      // Clobbered.
                           GetLinkRegisterState(),
                           kSaveFPRegs,
@@ skipping 496 matching lines @@
 
 
 void LCodeGen::DoValueOf(LValueOf* instr) {
   Register input = ToRegister(instr->value());
   Register result = ToRegister(instr->result());
   Register scratch = ToRegister(instr->temp());
   Label done;
 
   ASSERT(input.Is(result));
 
-  // If the object is a smi return it.
-  __ JumpIfSmi(input, &done);
+  if (!instr->hydrogen()->value()->IsHeapObject()) {
+    // If the object is a smi return it.
+    __ JumpIfSmi(input, &done);
+  }
 
   // If the object is not a value type, return the object, otherwise
   // return the value.
   __ JumpIfNotObjectType(input, scratch, scratch, JS_VALUE_TYPE, &done);
   __ Ldr(result, FieldMemOperand(input, JSValue::kValueOffset));
 
   __ Bind(&done);
 }
 
 
@@ skipping 75 matching lines @@
   __ Bind(&out_of_object);
   __ Ldr(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
   // Index is equal to negated out of object property index plus 1.
   __ Sub(result, result, Operand::UntagSmiAndScale(index, kPointerSizeLog2));
   __ Ldr(result, FieldMemOperand(result,
                                  FixedArray::kHeaderSize - kPointerSize));
   __ Bind(&done);
 }
 
 } }  // namespace v8::internal