[stubs] Introduce a proper ToBooleanStub.

src/code-stubs.cc

 // Copyright 2012 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/code-stubs.h"
 
 #include <sstream>
 
 #include "src/bootstrapper.h"
 #include "src/compiler/code-stub-assembler.h"
@@ skipping 455 matching lines @@
 void StringLengthStub::GenerateAssembly(
     compiler::CodeStubAssembler* assembler) const {
   compiler::Node* value = assembler->Parameter(0);
   compiler::Node* string =
       assembler->LoadObjectField(value, JSValue::kValueOffset);
   compiler::Node* result =
       assembler->LoadObjectField(string, String::kLengthOffset);
   assembler->Return(result);
 }
 
+void ToBooleanStub::GenerateAssembly(
+    compiler::CodeStubAssembler* assembler) const {
+  typedef compiler::Node Node;
+  typedef compiler::CodeStubAssembler::Label Label;
+
+  Node* value = assembler->Parameter(0);
+  Label if_valueissmi(assembler), if_valueisnotsmi(assembler);
+
+  // Check if {value} is a Smi or a HeapObject.
+  assembler->Branch(assembler->WordIsSmi(value), &if_valueissmi,
+                    &if_valueisnotsmi);
+
+  assembler->Bind(&if_valueissmi);
+  {
+    // The {value} is a Smi, only need to check against zero.
+    Label if_valueiszero(assembler), if_valueisnotzero(assembler);
+    assembler->Branch(assembler->SmiEqual(value, assembler->SmiConstant(0)),
+                      &if_valueiszero, &if_valueisnotzero);
+
+    assembler->Bind(&if_valueiszero);
+    assembler->Return(assembler->BooleanConstant(false));
+
+    assembler->Bind(&if_valueisnotzero);
+    assembler->Return(assembler->BooleanConstant(true));
+  }
+
+  assembler->Bind(&if_valueisnotsmi);
+  {
+    Label if_valueisstring(assembler), if_valueisheapnumber(assembler),
+        if_valueisoddball(assembler), if_valueisother(assembler);
+
+    // The {value} is a HeapObject, load its map.
+    Node* value_map = assembler->LoadObjectField(value, HeapObject::kMapOffset);
+
+    // Load the {value}s instance type.
+    Node* value_instancetype = assembler->Load(
+        MachineType::Uint8(), value_map,
+        assembler->IntPtrConstant(Map::kInstanceTypeOffset - kHeapObjectTag));
+
+    // Dispatch based on the instance type; we distinguish all String instance
+    // types, the HeapNumber type and the Oddball type.
+    size_t const kNumCases = FIRST_NONSTRING_TYPE + 2;
+    Label* case_labels[kNumCases];
+    int32_t case_values[kNumCases];
+    for (int32_t i = 0; i < FIRST_NONSTRING_TYPE; ++i) {
+      case_labels[i] = new Label(assembler);
+      case_values[i] = i;
+    }
+    case_labels[FIRST_NONSTRING_TYPE + 0] = &if_valueisheapnumber;
+    case_values[FIRST_NONSTRING_TYPE + 0] = HEAP_NUMBER_TYPE;
+    case_labels[FIRST_NONSTRING_TYPE + 1] = &if_valueisoddball;
+    case_values[FIRST_NONSTRING_TYPE + 1] = ODDBALL_TYPE;
+    assembler->Switch(value_instancetype, &if_valueisother, case_values,
+                      case_labels, arraysize(case_values));
+    for (int32_t i = 0; i < FIRST_NONSTRING_TYPE; ++i) {
+      assembler->Bind(case_labels[i]);
+      assembler->Goto(&if_valueisstring);
+      delete case_labels[i];
+    }
+
+    assembler->Bind(&if_valueisstring);
+    {
+      // Load the string length field of the {value}.
+      Node* value_length =
+          assembler->LoadObjectField(value, String::kLengthOffset);
+
+      // Check if the {value} is the empty string.
+      Label if_valueisempty(assembler), if_valueisnotempty(assembler);
+      assembler->Branch(
+          assembler->SmiEqual(value_length, assembler->SmiConstant(0)),
+          &if_valueisempty, &if_valueisnotempty);
+
+      assembler->Bind(&if_valueisempty);
+      assembler->Return(assembler->BooleanConstant(false));
+
+      assembler->Bind(&if_valueisnotempty);
+      assembler->Return(assembler->BooleanConstant(true));
+    }
+
+    assembler->Bind(&if_valueisheapnumber);
+    {
+      Node* value_value = assembler->Load(
+          MachineType::Float64(), value,
+          assembler->IntPtrConstant(HeapNumber::kValueOffset - kHeapObjectTag));
+
+      Label if_valueispositive(assembler), if_valueisnotpositive(assembler),
+          if_valueisnegative(assembler), if_valueisnanorzero(assembler);
+      assembler->Branch(assembler->Float64LessThan(
+                            assembler->Float64Constant(0.0), value_value),
+                        &if_valueispositive, &if_valueisnotpositive);
+
+      assembler->Bind(&if_valueispositive);
+      assembler->Return(assembler->BooleanConstant(true));
+
+      assembler->Bind(&if_valueisnotpositive);
+      assembler->Branch(assembler->Float64LessThan(
+                            value_value, assembler->Float64Constant(0.0)),
+                        &if_valueisnegative, &if_valueisnanorzero);
+
+      assembler->Bind(&if_valueisnegative);
+      assembler->Return(assembler->BooleanConstant(true));
+
+      assembler->Bind(&if_valueisnanorzero);
+      assembler->Return(assembler->BooleanConstant(false));
+    }
+
+    assembler->Bind(&if_valueisoddball);
+    {
+      // The {value} is an Oddball, and every Oddball knows its boolean value.
+      Node* value_toboolean =
+          assembler->LoadObjectField(value, Oddball::kToBooleanOffset);
+      assembler->Return(value_toboolean);
+    }
+
+    assembler->Bind(&if_valueisother);
+    {
+      Node* value_map_bitfield = assembler->Load(
+          MachineType::Uint8(), value_map,
+          assembler->IntPtrConstant(Map::kBitFieldOffset - kHeapObjectTag));
+      Node* value_map_undetectable = assembler->Word32And(
+          value_map_bitfield,
+          assembler->Int32Constant(1 << Map::kIsUndetectable));
+
+      // Check if the {value} is undetectable.
+      Label if_valueisundetectable(assembler),
+          if_valueisnotundetectable(assembler);
+      assembler->Branch(assembler->Word32Equal(value_map_undetectable,
+                                               assembler->Int32Constant(0)),
+                        &if_valueisnotundetectable, &if_valueisundetectable);
+
+      assembler->Bind(&if_valueisundetectable);
+      assembler->Return(assembler->BooleanConstant(false));
+
+      assembler->Bind(&if_valueisnotundetectable);
+      assembler->Return(assembler->BooleanConstant(true));
+    }
+  }
+}
 
 template<class StateType>
 void HydrogenCodeStub::TraceTransition(StateType from, StateType to) {
   // Note: Although a no-op transition is semantically OK, it is hinting at a
   // bug somewhere in our state transition machinery.
   DCHECK(from != to);
   if (!FLAG_trace_ic) return;
   OFStream os(stdout);
   os << "[";
   PrintBaseName(os);
@@ skipping 174 matching lines @@
     CodeStubDescriptor* descriptor) {
   descriptor->Initialize();
 }
 
 
 void AllocateInNewSpaceStub::InitializeDescriptor(
     CodeStubDescriptor* descriptor) {
   descriptor->Initialize();
 }
 
-
-void ToBooleanStub::InitializeDescriptor(CodeStubDescriptor* descriptor) {
+void ToBooleanICStub::InitializeDescriptor(CodeStubDescriptor* descriptor) {
   descriptor->Initialize(FUNCTION_ADDR(Runtime_ToBooleanIC_Miss));
   descriptor->SetMissHandler(ExternalReference(
       Runtime::FunctionForId(Runtime::kToBooleanIC_Miss), isolate()));
 }
 
 
 void BinaryOpICStub::InitializeDescriptor(CodeStubDescriptor* descriptor) {
   descriptor->Initialize(FUNCTION_ADDR(Runtime_BinaryOpIC_Miss));
   descriptor->SetMissHandler(ExternalReference(
       Runtime::FunctionForId(Runtime::kBinaryOpIC_Miss), isolate()));
@@ skipping 81 matching lines @@
 std::ostream& ArrayConstructorStubBase::BasePrintName(
     std::ostream& os,  // NOLINT
     const char* name) const {
   os << name << "_" << ElementsKindToString(elements_kind());
   if (override_mode() == DISABLE_ALLOCATION_SITES) {
     os << "_DISABLE_ALLOCATION_SITES";
   }
   return os;
 }
 
-
-bool ToBooleanStub::UpdateStatus(Handle<Object> object) {
+bool ToBooleanICStub::UpdateStatus(Handle<Object> object) {
   Types new_types = types();
   Types old_types = new_types;
   bool to_boolean_value = new_types.UpdateStatus(object);
   TraceTransition(old_types, new_types);
   set_sub_minor_key(TypesBits::update(sub_minor_key(), new_types.ToIntegral()));
   return to_boolean_value;
 }
 
-
-void ToBooleanStub::PrintState(std::ostream& os) const {  // NOLINT
+void ToBooleanICStub::PrintState(std::ostream& os) const {  // NOLINT
   os << types();
 }
 
-
-std::ostream& operator<<(std::ostream& os, const ToBooleanStub::Types& s) {
+std::ostream& operator<<(std::ostream& os, const ToBooleanICStub::Types& s) {
   os << "(";
   SimpleListPrinter p(os);
   if (s.IsEmpty()) p.Add("None");
-  if (s.Contains(ToBooleanStub::UNDEFINED)) p.Add("Undefined");
-  if (s.Contains(ToBooleanStub::BOOLEAN)) p.Add("Bool");
-  if (s.Contains(ToBooleanStub::NULL_TYPE)) p.Add("Null");
-  if (s.Contains(ToBooleanStub::SMI)) p.Add("Smi");
-  if (s.Contains(ToBooleanStub::SPEC_OBJECT)) p.Add("SpecObject");
-  if (s.Contains(ToBooleanStub::STRING)) p.Add("String");
-  if (s.Contains(ToBooleanStub::SYMBOL)) p.Add("Symbol");
-  if (s.Contains(ToBooleanStub::HEAP_NUMBER)) p.Add("HeapNumber");
-  if (s.Contains(ToBooleanStub::SIMD_VALUE)) p.Add("SimdValue");
+  if (s.Contains(ToBooleanICStub::UNDEFINED)) p.Add("Undefined");
+  if (s.Contains(ToBooleanICStub::BOOLEAN)) p.Add("Bool");
+  if (s.Contains(ToBooleanICStub::NULL_TYPE)) p.Add("Null");
+  if (s.Contains(ToBooleanICStub::SMI)) p.Add("Smi");
+  if (s.Contains(ToBooleanICStub::SPEC_OBJECT)) p.Add("SpecObject");
+  if (s.Contains(ToBooleanICStub::STRING)) p.Add("String");
+  if (s.Contains(ToBooleanICStub::SYMBOL)) p.Add("Symbol");
+  if (s.Contains(ToBooleanICStub::HEAP_NUMBER)) p.Add("HeapNumber");
+  if (s.Contains(ToBooleanICStub::SIMD_VALUE)) p.Add("SimdValue");
   return os << ")";
 }
 
-
-bool ToBooleanStub::Types::UpdateStatus(Handle<Object> object) {
+bool ToBooleanICStub::Types::UpdateStatus(Handle<Object> object) {
   if (object->IsUndefined()) {
     Add(UNDEFINED);
     return false;
   } else if (object->IsBoolean()) {
     Add(BOOLEAN);
     return object->IsTrue();
   } else if (object->IsNull()) {
     Add(NULL_TYPE);
     return false;
   } else if (object->IsSmi()) {
@@ skipping 17 matching lines @@
   } else if (object->IsSimd128Value()) {
     Add(SIMD_VALUE);
     return true;
   } else {
     // We should never see an internal object at runtime here!
     UNREACHABLE();
     return true;
   }
 }
 
-
-bool ToBooleanStub::Types::NeedsMap() const {
-  return Contains(ToBooleanStub::SPEC_OBJECT) ||
-         Contains(ToBooleanStub::STRING) || Contains(ToBooleanStub::SYMBOL) ||
-         Contains(ToBooleanStub::HEAP_NUMBER) ||
-         Contains(ToBooleanStub::SIMD_VALUE);
+bool ToBooleanICStub::Types::NeedsMap() const {
+  return Contains(ToBooleanICStub::SPEC_OBJECT) ||
+         Contains(ToBooleanICStub::STRING) ||
+         Contains(ToBooleanICStub::SYMBOL) ||
+         Contains(ToBooleanICStub::HEAP_NUMBER) ||
+         Contains(ToBooleanICStub::SIMD_VALUE);
 }
 
 
 void StubFailureTrampolineStub::GenerateAheadOfTime(Isolate* isolate) {
   StubFailureTrampolineStub stub1(isolate, NOT_JS_FUNCTION_STUB_MODE);
   StubFailureTrampolineStub stub2(isolate, JS_FUNCTION_STUB_MODE);
   stub1.GetCode();
   stub2.GetCode();
 }
 
@@ skipping 48 matching lines @@
   if (type->Is(Type::UntaggedPointer())) {
     return Representation::External();
   }
 
   DCHECK(!type->Is(Type::Untagged()));
   return Representation::Tagged();
 }
 
 }  // namespace internal
 }  // namespace v8