[Interpreter] Collect String feedback on CompareOps.

test/cctest/interpreter/test-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 <tuple>
 
 #include "src/v8.h"
 
 #include "src/execution.h"
 #include "src/handles.h"
@@ skipping 537 matching lines @@
        isolate->factory()->NewHeapNumber(Smi::kMaxValue + 1.0),
        BinaryOperationFeedback::kNumber},
       {Token::Value::ADD, isolate->factory()->NewHeapNumber(3.1415),
        Handle<Smi>(Smi::FromInt(3), isolate),
        isolate->factory()->NewHeapNumber(3.1415 + 3),
        BinaryOperationFeedback::kNumber},
       {Token::Value::ADD, isolate->factory()->NewHeapNumber(3.1415),
        isolate->factory()->NewHeapNumber(1.4142),
        isolate->factory()->NewHeapNumber(3.1415 + 1.4142),
        BinaryOperationFeedback::kNumber},
+      {Token::Value::ADD, isolate->factory()->NewStringFromAsciiChecked("foo"),
+       isolate->factory()->NewStringFromAsciiChecked("bar"),
+       isolate->factory()->NewStringFromAsciiChecked("foobar"),
+       BinaryOperationFeedback::kString},
       {Token::Value::ADD, Handle<Smi>(Smi::FromInt(2), isolate),
        isolate->factory()->NewStringFromAsciiChecked("2"),
        isolate->factory()->NewStringFromAsciiChecked("22"),
        BinaryOperationFeedback::kAny},
       // SUB
       {Token::Value::SUB, Handle<Smi>(Smi::FromInt(2), isolate),
        Handle<Smi>(Smi::FromInt(3), isolate),
        Handle<Smi>(Smi::FromInt(-1), isolate),
        BinaryOperationFeedback::kSignedSmall},
       {Token::Value::SUB, Handle<Smi>(Smi::FromInt(Smi::kMinValue), isolate),
@@ skipping 1234 matching lines @@
 
         Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
         InterpreterTester tester(isolate, bytecode_array, vector);
         auto callable = tester.GetCallable<>();
         Handle<Object> return_value = callable().ToHandleChecked();
         CHECK(return_value->IsBoolean());
         CHECK_EQ(return_value->BooleanValue(),
                  CompareC(comparison, inputs[i], inputs[j]));
         Object* feedback = vector->Get(slot);
         CHECK(feedback->IsSmi());
-        CHECK_EQ(CompareOperationFeedback::kAny,
+        CHECK_EQ(CompareOperationFeedback::kString,
                  static_cast<Smi*>(feedback)->value());
       }
     }
   }
 }
 
 
 TEST(InterpreterMixedComparisons) {
   // This test compares a HeapNumber with a String. The latter is
   // convertible to a HeapNumber so comparison will be between numeric
   // values except for the strict comparisons where no conversion is
   // performed.
-  const char* inputs[] = {"-1.77", "-40.333", "0.01", "55.77e5", "2.01"};
+  const char* inputs[] = {"-1.77", "-40.333", "0.01", "55.77e50", "2.01"};
 
   UnicodeCache unicode_cache;
 
   for (size_t c = 0; c < arraysize(kComparisonTypes); c++) {
     Token::Value comparison = kComparisonTypes[c];
     for (size_t i = 0; i < arraysize(inputs); i++) {
       for (size_t j = 0; j < arraysize(inputs); j++) {
         for (int pass = 0; pass < 2; pass++) {
           const char* lhs_cstr = inputs[i];
           const char* rhs_cstr = inputs[j];
@@ skipping 32 matching lines @@
           Handle<BytecodeArray> bytecode_array =
               builder.ToBytecodeArray(isolate);
           InterpreterTester tester(isolate, bytecode_array, vector);
           auto callable = tester.GetCallable<>();
           Handle<Object> return_value = callable().ToHandleChecked();
           CHECK(return_value->IsBoolean());
           CHECK_EQ(return_value->BooleanValue(),
                    CompareC(comparison, lhs, rhs, true));
           Object* feedback = vector->Get(slot);
           CHECK(feedback->IsSmi());
-          CHECK_EQ(CompareOperationFeedback::kAny,
-                   static_cast<Smi*>(feedback)->value());
+          // kNumber | kString gets converted to CompareOperationHint::kAny.
+          int expected_feedback = CompareOperationFeedback::kNumber |
+                                  CompareOperationFeedback::kString;
+          CHECK_EQ(expected_feedback, static_cast<Smi*>(feedback)->value());
         }
       }
     }
   }
 }
 
 TEST(InterpreterStrictNotEqual) {
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
   Factory* factory = isolate->factory();
@@ skipping 2931 matching lines @@
     auto callable = tester.GetCallable<>();
 
     Handle<i::Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*tests[i].second));
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8