[Interpreter] Collect NumberOrOddball feedback in CompareOps.

src/interpreter/interpreter.cc

 // Copyright 2015 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/interpreter/interpreter.h"
 
 #include <fstream>
 #include <memory>
 
 #include "src/ast/prettyprinter.h"
@@ skipping 985 matching lines @@
   // try-finally blocks and generators), and we could get rid of this by
   // introducing Smi equality tests.
   Label gather_type_feedback(assembler), do_compare(assembler);
   __ Branch(__ WordEqual(slot_index, __ IntPtrConstant(0)), &do_compare,
             &gather_type_feedback);
 
   __ Bind(&gather_type_feedback);
   {
     Variable var_type_feedback(assembler, MachineRepresentation::kWord32);
     Label lhs_is_not_smi(assembler), lhs_is_not_number(assembler),
-        lhs_is_not_string(assembler), gather_rhs_type(assembler),
-        update_feedback(assembler);
+        lhs_is_not_oddball(assembler), lhs_is_not_string(assembler),
+        gather_rhs_type(assembler), update_feedback(assembler);
 
     __ GotoUnless(__ TaggedIsSmi(lhs), &lhs_is_not_smi);
 
     var_type_feedback.Bind(
         __ Int32Constant(CompareOperationFeedback::kSignedSmall));
     __ Goto(&gather_rhs_type);
 
     __ Bind(&lhs_is_not_smi);
     {
       Node* lhs_map = __ LoadMap(lhs);
       __ GotoUnless(__ WordEqual(lhs_map, __ HeapNumberMapConstant()),
                     &lhs_is_not_number);
 
       var_type_feedback.Bind(
           __ Int32Constant(CompareOperationFeedback::kNumber));
       __ Goto(&gather_rhs_type);
 
       __ Bind(&lhs_is_not_number);
       {
         Node* lhs_instance_type = __ LoadInstanceType(lhs);
-        Node* lhs_type =
-            __ Select(__ IsStringInstanceType(lhs_instance_type),
-                      __ Int32Constant(CompareOperationFeedback::kString),
-                      __ Int32Constant(CompareOperationFeedback::kAny));
+        Node* lhs_is_oddball =
+            __ Word32Equal(lhs_instance_type, __ Int32Constant(ODDBALL_TYPE));
+        __ GotoUnless(lhs_is_oddball, &lhs_is_not_oddball);
 
-        var_type_feedback.Bind(lhs_type);
+        var_type_feedback.Bind(
+            __ Int32Constant(CompareOperationFeedback::kNumberOrOddball));
         __ Goto(&gather_rhs_type);
+
+        __ Bind(&lhs_is_not_oddball);
+        {
+          Node* lhs_type =
+              __ Select(__ IsStringInstanceType(lhs_instance_type),
+                        __ Int32Constant(CompareOperationFeedback::kString),
+                        __ Int32Constant(CompareOperationFeedback::kAny));
+
+          var_type_feedback.Bind(lhs_type);
+          __ Goto(&gather_rhs_type);
+        }
       }
     }
 
     __ Bind(&gather_rhs_type);
     {
-      Label rhs_is_not_smi(assembler), rhs_is_not_number(assembler);
+      Label rhs_is_not_smi(assembler), rhs_is_not_number(assembler),
+          rhs_is_not_oddball(assembler);
 
       __ GotoUnless(__ TaggedIsSmi(rhs), &rhs_is_not_smi);
 
       var_type_feedback.Bind(__ Word32Or(
           var_type_feedback.value(),
           __ Int32Constant(CompareOperationFeedback::kSignedSmall)));
       __ Goto(&update_feedback);
 
       __ Bind(&rhs_is_not_smi);
       {
         Node* rhs_map = __ LoadMap(rhs);
         __ GotoUnless(__ WordEqual(rhs_map, __ HeapNumberMapConstant()),
                       &rhs_is_not_number);
 
         var_type_feedback.Bind(
             __ Word32Or(var_type_feedback.value(),
                         __ Int32Constant(CompareOperationFeedback::kNumber)));
         __ Goto(&update_feedback);
 
         __ Bind(&rhs_is_not_number);
         {
           Node* rhs_instance_type = __ LoadInstanceType(rhs);
-          Node* rhs_type =
-              __ Select(__ IsStringInstanceType(rhs_instance_type),
-                        __ Int32Constant(CompareOperationFeedback::kString),
-                        __ Int32Constant(CompareOperationFeedback::kAny));
+          Node* rhs_is_oddball =
+              __ Word32Equal(rhs_instance_type, __ Int32Constant(ODDBALL_TYPE));
+          __ GotoUnless(rhs_is_oddball, &rhs_is_not_oddball);
+
           var_type_feedback.Bind(
-              __ Word32Or(var_type_feedback.value(), rhs_type));
-          __ Goto(&update_feedback);
+              __ Int32Constant(CompareOperationFeedback::kNumberOrOddball));
+          __ Goto(&do_compare);
+
+          __ Bind(&rhs_is_not_oddball);
+          {
+            Node* rhs_type =
+                __ Select(__ IsStringInstanceType(rhs_instance_type),
+                          __ Int32Constant(CompareOperationFeedback::kString),
+                          __ Int32Constant(CompareOperationFeedback::kAny));
+            var_type_feedback.Bind(
+                __ Word32Or(var_type_feedback.value(), rhs_type));
+            __ Goto(&update_feedback);
+          }
         }
       }
     }
 
     __ Bind(&update_feedback);
     {
       __ UpdateFeedback(var_type_feedback.value(), type_feedback_vector,
                         slot_index);
       __ Goto(&do_compare);
     }
@@ skipping 1654 matching lines @@
   __ StoreObjectField(generator, JSGeneratorObject::kContinuationOffset,
       __ SmiTag(new_state));
   __ SetAccumulator(old_state);
 
   __ Dispatch();
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8