[stubs] Add more helper methods for heap constants

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/ast/ast.h"
 #include "src/bootstrapper.h"
@@ skipping 713 matching lines @@
       }
 
       assembler->Bind(&if_rhsisnotsmi);
       {
         // Load the map of {rhs}.
         Node* rhs_map = assembler->LoadMap(rhs);
 
         // Check if the {rhs} is a HeapNumber.
         Label if_rhsisnumber(assembler),
             if_rhsisnotnumber(assembler, Label::kDeferred);
-        Node* number_map = assembler->HeapNumberMapConstant();
-        assembler->Branch(assembler->WordEqual(rhs_map, number_map),
-                          &if_rhsisnumber, &if_rhsisnotnumber);
+        assembler->Branch(assembler->IsHeapNumberMap(rhs_map), &if_rhsisnumber,
+                          &if_rhsisnotnumber);
 
         assembler->Bind(&if_rhsisnumber);
         {
           var_fadd_lhs.Bind(assembler->SmiToFloat64(lhs));
           var_fadd_rhs.Bind(assembler->LoadHeapNumberValue(rhs));
           assembler->Goto(&do_fadd);
         }
 
         assembler->Bind(&if_rhsisnotnumber);
         {
@@ skipping 343 matching lines @@
         assembler->Goto(&end);
       }
     }
 
     assembler->Bind(&if_rhsisnotsmi);
     {
       // Load the map of {rhs}.
       Node* rhs_map = assembler->LoadMap(rhs);
 
       // Check if the {rhs} is a HeapNumber.
-      assembler->GotoUnless(
-          assembler->WordEqual(rhs_map, assembler->HeapNumberMapConstant()),
-          &call_add_stub);
+      assembler->GotoUnless(assembler->IsHeapNumberMap(rhs_map),
+                            &call_add_stub);
 
       var_fadd_lhs.Bind(assembler->SmiToFloat64(lhs));
       var_fadd_rhs.Bind(assembler->LoadHeapNumberValue(rhs));
       assembler->Goto(&do_fadd);
     }
   }
 
   assembler->Bind(&if_lhsisnotsmi);
   {
     // Load the map of {lhs}.
     Node* lhs_map = assembler->LoadMap(lhs);
 
     // Check if {lhs} is a HeapNumber.
     Label if_lhsisnumber(assembler), if_lhsisnotnumber(assembler);
-    assembler->GotoUnless(
-        assembler->WordEqual(lhs_map, assembler->HeapNumberMapConstant()),
-        &call_add_stub);
+    assembler->GotoUnless(assembler->IsHeapNumberMap(lhs_map), &call_add_stub);
 
     // Check if the {rhs} is Smi.
     Label if_rhsissmi(assembler), if_rhsisnotsmi(assembler);
     assembler->Branch(assembler->WordIsSmi(rhs), &if_rhsissmi, &if_rhsisnotsmi);
 
     assembler->Bind(&if_rhsissmi);
     {
       var_fadd_lhs.Bind(assembler->LoadHeapNumberValue(lhs));
       var_fadd_rhs.Bind(assembler->SmiToFloat64(rhs));
       assembler->Goto(&do_fadd);
     }
 
     assembler->Bind(&if_rhsisnotsmi);
     {
       // Load the map of {rhs}.
       Node* rhs_map = assembler->LoadMap(rhs);
 
       // Check if the {rhs} is a HeapNumber.
-      Node* number_map = assembler->HeapNumberMapConstant();
-      assembler->GotoUnless(assembler->WordEqual(rhs_map, number_map),
+      assembler->GotoUnless(assembler->IsHeapNumberMap(rhs_map),
                             &call_add_stub);
 
       var_fadd_lhs.Bind(assembler->LoadHeapNumberValue(lhs));
       var_fadd_rhs.Bind(assembler->LoadHeapNumberValue(rhs));
       assembler->Goto(&do_fadd);
     }
   }
 
   assembler->Bind(&do_fadd);
   {
@@ skipping 86 matching lines @@
       }
 
       assembler->Bind(&if_rhsisnotsmi);
       {
         // Load the map of the {rhs}.
         Node* rhs_map = assembler->LoadMap(rhs);
 
         // Check if {rhs} is a HeapNumber.
         Label if_rhsisnumber(assembler),
             if_rhsisnotnumber(assembler, Label::kDeferred);
-        Node* number_map = assembler->HeapNumberMapConstant();
-        assembler->Branch(assembler->WordEqual(rhs_map, number_map),
-                          &if_rhsisnumber, &if_rhsisnotnumber);
+        assembler->Branch(assembler->IsHeapNumberMap(rhs_map), &if_rhsisnumber,
+                          &if_rhsisnotnumber);
 
         assembler->Bind(&if_rhsisnumber);
         {
           // Perform a floating point subtraction.
           var_fsub_lhs.Bind(assembler->SmiToFloat64(lhs));
           var_fsub_rhs.Bind(assembler->LoadHeapNumberValue(rhs));
           assembler->Goto(&do_fsub);
         }
 
         assembler->Bind(&if_rhsisnotnumber);
@@ skipping 140 matching lines @@
       var_result.Bind(assembler->Projection(0, pair));
       assembler->Goto(&end);
     }
 
     assembler->Bind(&if_rhsisnotsmi);
     {
       // Load the map of the {rhs}.
       Node* rhs_map = assembler->LoadMap(rhs);
 
       // Check if {rhs} is a HeapNumber.
-      assembler->GotoUnless(
-          assembler->WordEqual(rhs_map, assembler->HeapNumberMapConstant()),
-          &call_subtract_stub);
+      assembler->GotoUnless(assembler->IsHeapNumberMap(rhs_map),
+                            &call_subtract_stub);
 
       // Perform a floating point subtraction.
       var_fsub_lhs.Bind(assembler->SmiToFloat64(lhs));
       var_fsub_rhs.Bind(assembler->LoadHeapNumberValue(rhs));
       assembler->Goto(&do_fsub);
     }
   }
 
   assembler->Bind(&if_lhsisnotsmi);
   {
     // Load the map of the {lhs}.
     Node* lhs_map = assembler->LoadMap(lhs);
 
     // Check if the {lhs} is a HeapNumber.
-    assembler->GotoUnless(
-        assembler->WordEqual(lhs_map, assembler->HeapNumberMapConstant()),
-        &call_subtract_stub);
+    assembler->GotoUnless(assembler->IsHeapNumberMap(lhs_map),
+                          &call_subtract_stub);
 
     // Check if the {rhs} is a Smi.
     Label if_rhsissmi(assembler), if_rhsisnotsmi(assembler);
     assembler->Branch(assembler->WordIsSmi(rhs), &if_rhsissmi, &if_rhsisnotsmi);
 
     assembler->Bind(&if_rhsissmi);
     {
       // Perform a floating point subtraction.
       var_fsub_lhs.Bind(assembler->LoadHeapNumberValue(lhs));
       var_fsub_rhs.Bind(assembler->SmiToFloat64(rhs));
       assembler->Goto(&do_fsub);
     }
 
     assembler->Bind(&if_rhsisnotsmi);
     {
       // Load the map of the {rhs}.
       Node* rhs_map = assembler->LoadMap(rhs);
 
       // Check if the {rhs} is a HeapNumber.
-      assembler->GotoUnless(
-          assembler->WordEqual(rhs_map, assembler->HeapNumberMapConstant()),
-          &call_subtract_stub);
+      assembler->GotoUnless(assembler->IsHeapNumberMap(rhs_map),
+                            &call_subtract_stub);
 
       // Perform a floating point subtraction.
       var_fsub_lhs.Bind(assembler->LoadHeapNumberValue(lhs));
       var_fsub_rhs.Bind(assembler->LoadHeapNumberValue(rhs));
       assembler->Goto(&do_fsub);
     }
   }
 
   assembler->Bind(&do_fsub);
   {
@@ skipping 1105 matching lines @@
         assembler->Goto(&do_finc);
       }
     }
 
     assembler->Bind(&if_isnotsmi);
     {
       // Check if the value is a HeapNumber.
       Label if_valueisnumber(assembler),
           if_valuenotnumber(assembler, Label::kDeferred);
       Node* value_map = assembler->LoadMap(value);
-      Node* number_map = assembler->HeapNumberMapConstant();
-      assembler->Branch(assembler->WordEqual(value_map, number_map),
+      assembler->Branch(assembler->IsHeapNumberMap(value_map),
                         &if_valueisnumber, &if_valuenotnumber);
 
       assembler->Bind(&if_valueisnumber);
       {
         // Load the HeapNumber value.
         var_finc_value.Bind(assembler->LoadHeapNumberValue(value));
         assembler->Goto(&do_finc);
       }
 
       assembler->Bind(&if_valuenotnumber);
@@ skipping 82 matching lines @@
         assembler->Goto(&do_fdec);
       }
     }
 
     assembler->Bind(&if_isnotsmi);
     {
       // Check if the value is a HeapNumber.
       Label if_valueisnumber(assembler),
           if_valuenotnumber(assembler, Label::kDeferred);
       Node* value_map = assembler->LoadMap(value);
-      Node* number_map = assembler->HeapNumberMapConstant();
-      assembler->Branch(assembler->WordEqual(value_map, number_map),
+      assembler->Branch(assembler->IsHeapNumberMap(value_map),
                         &if_valueisnumber, &if_valuenotnumber);
 
       assembler->Bind(&if_valueisnumber);
       {
         // Load the HeapNumber value.
         var_fdec_value.Bind(assembler->LoadHeapNumberValue(value));
         assembler->Goto(&do_fdec);
       }
 
       assembler->Bind(&if_valuenotnumber);
@@ skipping 50 matching lines @@
   Node* context = assembler->Parameter(Descriptor::kContext);
 
   Variable constructor_function_index_var(assembler,
                                           MachineType::PointerRepresentation());
 
   assembler->Branch(assembler->WordIsSmi(object), &if_number, &if_notsmi);
 
   assembler->Bind(&if_notsmi);
   Node* map = assembler->LoadMap(object);
 
-  assembler->GotoIf(
-      assembler->WordEqual(map, assembler->HeapNumberMapConstant()),
-      &if_number);
+  assembler->GotoIf(assembler->IsHeapNumberMap(map), &if_number);
 
   Node* instance_type = assembler->LoadMapInstanceType(map);
   assembler->GotoIf(
       assembler->Int32GreaterThanOrEqual(
           instance_type, assembler->Int32Constant(FIRST_JS_RECEIVER_TYPE)),
       &if_jsreceiver);
 
   Node* constructor_function_index =
       assembler->LoadMapConstructorFunctionIndex(map);
   assembler->GotoIf(assembler->WordEqual(constructor_function_index,
@@ skipping 47 matching lines @@
 
   Label return_number(assembler, Label::kDeferred), if_oddball(assembler),
       return_function(assembler), return_undefined(assembler),
       return_object(assembler), return_string(assembler),
       return_result(assembler);
 
   assembler->GotoIf(assembler->WordIsSmi(value), &return_number);
 
   Node* map = assembler->LoadMap(value);
 
-  assembler->GotoIf(
-      assembler->WordEqual(map, assembler->HeapNumberMapConstant()),
-      &return_number);
+  assembler->GotoIf(assembler->IsHeapNumberMap(map), &return_number);
 
   Node* instance_type = assembler->LoadMapInstanceType(map);
 
   assembler->GotoIf(assembler->Word32Equal(
                         instance_type, assembler->Int32Constant(ODDBALL_TYPE)),
                     &if_oddball);
 
   Node* callable_or_undetectable_mask =
       assembler->Word32And(assembler->LoadMapBitField(map),
                            assembler->Int32Constant(1 << Map::kIsCallable |
@@ skipping 206 matching lines @@
             break;
         }
       }
 
       assembler->Bind(&if_rhsisnotsmi);
       {
         // Load the map of {rhs}.
         Node* rhs_map = assembler->LoadMap(rhs);
 
         // Check if the {rhs} is a HeapNumber.
-        Node* number_map = assembler->HeapNumberMapConstant();
         Label if_rhsisnumber(assembler),
             if_rhsisnotnumber(assembler, Label::kDeferred);
-        assembler->Branch(assembler->WordEqual(rhs_map, number_map),
-                          &if_rhsisnumber, &if_rhsisnotnumber);
+        assembler->Branch(assembler->IsHeapNumberMap(rhs_map), &if_rhsisnumber,
+                          &if_rhsisnotnumber);
 
         assembler->Bind(&if_rhsisnumber);
         {
           // Convert the {lhs} and {rhs} to floating point values, and
           // perform a floating point comparison.
           var_fcmp_lhs.Bind(assembler->SmiToFloat64(lhs));
           var_fcmp_rhs.Bind(assembler->LoadHeapNumberValue(rhs));
           assembler->Goto(&do_fcmp);
         }
 
@@ skipping 285 matching lines @@
   Label if_valueissmi(assembler), if_valueisnotsmi(assembler);
   assembler->Branch(assembler->WordIsSmi(value), &if_valueissmi,
                     &if_valueisnotsmi);
 
   assembler->Bind(&if_valueisnotsmi);
   {
     // Load the map of {value}.
     Node* value_map = assembler->LoadMap(value);
 
     // Check if {value} (and therefore {rhs}) is a HeapNumber.
-    Node* number_map = assembler->HeapNumberMapConstant();
     Label if_valueisnumber(assembler), if_valueisnotnumber(assembler);
-    assembler->Branch(assembler->WordEqual(value_map, number_map),
-                      &if_valueisnumber, &if_valueisnotnumber);
+    assembler->Branch(assembler->IsHeapNumberMap(value_map), &if_valueisnumber,
+                      &if_valueisnotnumber);
 
     assembler->Bind(&if_valueisnumber);
     {
       // Convert {value} (and therefore {rhs}) to floating point value.
       Node* value_value = assembler->LoadHeapNumberValue(value);
 
       // Check if the HeapNumber value is a NaN.
       assembler->BranchIfFloat64IsNaN(value_value, if_notequal, if_equal);
     }
 
@@ skipping 116 matching lines @@
             {
               // The {rhs} is a String and the {lhs} is a Smi; we need
               // to convert the {rhs} to a Number and compare the output to
               // the Number on the {lhs}.
               assembler->Goto(&do_rhsstringtonumber);
             }
 
             assembler->Bind(&if_rhsisnotstring);
             {
               // Check if the {rhs} is a Boolean.
-              Node* boolean_map = assembler->BooleanMapConstant();
               Label if_rhsisboolean(assembler), if_rhsisnotboolean(assembler);
-              assembler->Branch(assembler->WordEqual(rhs_map, boolean_map),
+              assembler->Branch(assembler->IsBooleanMap(rhs_map),
                                 &if_rhsisboolean, &if_rhsisnotboolean);
 
               assembler->Bind(&if_rhsisboolean);
               {
                 // The {rhs} is a Boolean, load its number value.
                 var_rhs.Bind(
                     assembler->LoadObjectField(rhs, Oddball::kToNumberOffset));
                 assembler->Goto(&loop);
               }
 
@@ skipping 175 matching lines @@
                   var_lhs.Bind(rhs);
                   var_rhs.Bind(lhs);
                   assembler->Goto(&loop);
                 }
 
                 assembler->Bind(&if_rhsisnotreceiver);
                 {
                   // Check if {rhs} is a Boolean.
                   Label if_rhsisboolean(assembler),
                       if_rhsisnotboolean(assembler);
-                  Node* boolean_map = assembler->BooleanMapConstant();
-                  assembler->Branch(assembler->WordEqual(rhs_map, boolean_map),
+                  assembler->Branch(assembler->IsBooleanMap(rhs_map),
                                     &if_rhsisboolean, &if_rhsisnotboolean);
 
                   assembler->Bind(&if_rhsisboolean);
                   {
                     // The {rhs} is a Boolean, convert it to a Smi first.
                     var_rhs.Bind(assembler->LoadObjectField(
                         rhs, Oddball::kToNumberOffset));
                     assembler->Goto(&loop);
                   }
 
@@ skipping 584 matching lines @@
   // runtime.
   Node* cell_contents =
       assembler->LoadObjectField(cell, PropertyCell::kValueOffset);
 
   PropertyCellType cell_type = this->cell_type();
   if (cell_type == PropertyCellType::kConstant ||
       cell_type == PropertyCellType::kUndefined) {
     // This is always valid for all states a cell can be in.
     assembler->GotoIf(assembler->WordNotEqual(cell_contents, value), &miss);
   } else {
-    assembler->GotoIf(
-        assembler->WordEqual(cell_contents, assembler->TheHoleConstant()),
-        &miss);
+    assembler->GotoIf(assembler->IsTheHole(cell_contents), &miss);
 
     // When dealing with constant types, the type may be allowed to change, as
     // long as optimized code remains valid.
     bool value_is_smi = false;
     if (cell_type == PropertyCellType::kConstantType) {
       switch (constant_type()) {
         case PropertyCellConstantType::kSmi:
           assembler->GotoUnless(assembler->WordIsSmi(value), &miss);
           value_is_smi = true;
           break;
@@ skipping 201 matching lines @@
 
     // Check if {len} is a positive Smi.
     assembler->GotoIf(assembler->WordIsPositiveSmi(len), &return_len);
 
     // Check if {len} is a (negative) Smi.
     assembler->GotoIf(assembler->WordIsSmi(len), &return_zero);
 
     // Check if {len} is a HeapNumber.
     Label if_lenisheapnumber(assembler),
         if_lenisnotheapnumber(assembler, Label::kDeferred);
-    assembler->Branch(assembler->WordEqual(assembler->LoadMap(len),
-                                           assembler->HeapNumberMapConstant()),
+    assembler->Branch(assembler->IsHeapNumberMap(assembler->LoadMap(len)),
                       &if_lenisheapnumber, &if_lenisnotheapnumber);
 
     assembler->Bind(&if_lenisheapnumber);
     {
       // Load the floating-point value of {len}.
       Node* len_value = assembler->LoadHeapNumberValue(len);
 
       // Check if {len} is not greater than zero.
       assembler->GotoUnless(assembler->Float64GreaterThan(
                                 len_value, assembler->Float64Constant(0.0)),
@@ skipping 102 matching lines @@
   typedef compiler::Node Node;
   typedef compiler::CodeAssembler::Label Label;
   typedef compiler::CodeAssembler::Variable Variable;
 
   Node* literals_array =
       assembler->LoadObjectField(closure, JSFunction::kLiteralsOffset);
   Node* allocation_site = assembler->LoadFixedArrayElement(
       literals_array, literals_index,
       LiteralsArray::kFirstLiteralIndex * kPointerSize,
       CodeStubAssembler::SMI_PARAMETERS);
-  Node* undefined = assembler->UndefinedConstant();
-  assembler->GotoIf(assembler->WordEqual(allocation_site, undefined),
-                    call_runtime);
+  assembler->GotoIf(assembler->IsUndefined(allocation_site), call_runtime);
 
   // Calculate the object and allocation size based on the properties count.
   Node* object_size = assembler->IntPtrAdd(
       assembler->WordShl(properties_count, kPointerSizeLog2),
       assembler->IntPtrConstant(JSObject::kHeaderSize));
   Node* allocation_size = object_size;
   if (FLAG_allocation_site_pretenuring) {
     allocation_size = assembler->IntPtrAdd(
         object_size, assembler->IntPtrConstant(AllocationMemento::kSize));
   }
@@ skipping 618 matching lines @@
                                               compiler::Node* flags,
                                               compiler::Node* context) {
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
   typedef compiler::Node Node;
 
   Label call_runtime(assembler, Label::kDeferred), end(assembler);
 
   Variable result(assembler, MachineRepresentation::kTagged);
 
-  Node* undefined = assembler->UndefinedConstant();
   Node* literals_array =
       assembler->LoadObjectField(closure, JSFunction::kLiteralsOffset);
   Node* boilerplate = assembler->LoadFixedArrayElement(
       literals_array, literal_index,
       LiteralsArray::kFirstLiteralIndex * kPointerSize,
       CodeStubAssembler::SMI_PARAMETERS);
-  assembler->GotoIf(assembler->WordEqual(boilerplate, undefined),
-                    &call_runtime);
+  assembler->GotoIf(assembler->IsUndefined(boilerplate), &call_runtime);
 
   {
     int size = JSRegExp::kSize + JSRegExp::kInObjectFieldCount * kPointerSize;
     Node* copy = assembler->Allocate(size);
     for (int offset = 0; offset < size; offset += kPointerSize) {
       Node* value = assembler->LoadObjectField(boilerplate, offset);
       assembler->StoreObjectFieldNoWriteBarrier(copy, offset, value);
     }
     result.Bind(copy);
     assembler->Goto(&end);
@@ skipping 84 matching lines @@
       fast_elements(assembler), return_result(assembler);
   Variable result(assembler, MachineRepresentation::kTagged);
 
   Node* literals_array =
       assembler->LoadObjectField(closure, JSFunction::kLiteralsOffset);
   Node* allocation_site = assembler->LoadFixedArrayElement(
       literals_array, literal_index,
       LiteralsArray::kFirstLiteralIndex * kPointerSize,
       CodeStubAssembler::SMI_PARAMETERS);
 
-  Node* undefined = assembler->UndefinedConstant();
-  assembler->GotoIf(assembler->WordEqual(allocation_site, undefined),
-                    call_runtime);
+  assembler->GotoIf(assembler->IsUndefined(allocation_site), call_runtime);
   allocation_site = assembler->LoadFixedArrayElement(
       literals_array, literal_index,
       LiteralsArray::kFirstLiteralIndex * kPointerSize,
       CodeStubAssembler::SMI_PARAMETERS);
 
   Node* boilerplate = assembler->LoadObjectField(
       allocation_site, AllocationSite::kTransitionInfoOffset);
   Node* boilerplate_map = assembler->LoadMap(boilerplate);
   Node* boilerplate_elements = assembler->LoadElements(boilerplate);
   Node* capacity = assembler->LoadFixedArrayBaseLength(boilerplate_elements);
   allocation_site =
       allocation_site_mode == TRACK_ALLOCATION_SITE ? allocation_site : nullptr;
 
   Node* zero = assembler->SmiConstant(Smi::FromInt(0));
   assembler->GotoIf(assembler->SmiEqual(capacity, zero), &zero_capacity);
 
   Node* elements_map = assembler->LoadMap(boilerplate_elements);
-  assembler->GotoIf(
-      assembler->WordEqual(elements_map, assembler->FixedCowArrayMapConstant()),
-      &cow_elements);
+  assembler->GotoIf(assembler->IsFixedCOWArrayMap(elements_map), &cow_elements);
 
-  assembler->GotoIf(
-      assembler->WordEqual(elements_map, assembler->FixedArrayMapConstant()),
-      &fast_elements);
+  assembler->GotoIf(assembler->IsFixedArrayMap(elements_map), &fast_elements);
   {
     assembler->Comment("fast double elements path");
     if (FLAG_debug_code) {
       Label correct_elements_map(assembler), abort(assembler, Label::kDeferred);
-      assembler->BranchIf(
-          assembler->WordEqual(elements_map,
-                               assembler->FixedDoubleArrayMapConstant()),
-          &correct_elements_map, &abort);
+      assembler->BranchIf(assembler->IsFixedDoubleArrayMap(elements_map),
+                          &correct_elements_map, &abort);
 
       assembler->Bind(&abort);
       {
         Node* abort_id = assembler->SmiConstant(
             Smi::FromInt(BailoutReason::kExpectedFixedDoubleArrayMap));
         assembler->TailCallRuntime(Runtime::kAbort, context, abort_id);
       }
       assembler->Bind(&correct_elements_map);
     }
 
@@ skipping 454 matching lines @@
 
   if (type == MachineType::Pointer()) {
     return Representation::External();
   }
 
   return Representation::Tagged();
 }
 
 }  // namespace internal
 }  // namespace v8