Revert "Add Smi::Zero and replace all Smi::FromInt(0) calls"

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 690 matching lines @@
       {Token::Value::SUB, Handle<Smi>(Smi::FromInt(2), isolate), 42,
        Handle<Smi>(Smi::FromInt(-40), isolate),
        BinaryOperationFeedback::kSignedSmall},
       {Token::Value::SUB, Handle<Smi>(Smi::FromInt(Smi::kMinValue), isolate), 1,
        isolate->factory()->NewHeapNumber(Smi::kMinValue - 1.0),
        BinaryOperationFeedback::kNumber},
       {Token::Value::SUB, isolate->factory()->NewHeapNumber(3.1415), 2,
        isolate->factory()->NewHeapNumber(3.1415 - 2.0),
        BinaryOperationFeedback::kNumber},
       {Token::Value::SUB, isolate->factory()->NewStringFromAsciiChecked("2"), 2,
-       Handle<Smi>(Smi::kZero, isolate), BinaryOperationFeedback::kAny},
+       Handle<Smi>(Smi::FromInt(0), isolate), BinaryOperationFeedback::kAny},
       // BIT_OR
       {Token::Value::BIT_OR, Handle<Smi>(Smi::FromInt(4), isolate), 1,
        Handle<Smi>(Smi::FromInt(5), isolate),
        BinaryOperationFeedback::kSignedSmall},
       {Token::Value::BIT_OR, isolate->factory()->NewHeapNumber(3.1415), 8,
        Handle<Smi>(Smi::FromInt(11), isolate),
        BinaryOperationFeedback::kNumber},
       {Token::Value::BIT_OR, isolate->factory()->NewStringFromAsciiChecked("2"),
        1, Handle<Smi>(Smi::FromInt(3), isolate), BinaryOperationFeedback::kAny},
       // BIT_AND
       {Token::Value::BIT_AND, Handle<Smi>(Smi::FromInt(3), isolate), 1,
        Handle<Smi>(Smi::FromInt(1), isolate),
        BinaryOperationFeedback::kSignedSmall},
       {Token::Value::BIT_AND, isolate->factory()->NewHeapNumber(3.1415), 2,
        Handle<Smi>(Smi::FromInt(2), isolate), BinaryOperationFeedback::kNumber},
       {Token::Value::BIT_AND,
        isolate->factory()->NewStringFromAsciiChecked("2"), 1,
-       Handle<Smi>(Smi::kZero, isolate), BinaryOperationFeedback::kAny},
+       Handle<Smi>(Smi::FromInt(0), isolate), BinaryOperationFeedback::kAny},
       // SHL
       {Token::Value::SHL, Handle<Smi>(Smi::FromInt(3), isolate), 1,
        Handle<Smi>(Smi::FromInt(6), isolate),
        BinaryOperationFeedback::kSignedSmall},
       {Token::Value::SHL, isolate->factory()->NewHeapNumber(3.1415), 2,
        Handle<Smi>(Smi::FromInt(12), isolate),
        BinaryOperationFeedback::kNumber},
       {Token::Value::SHL, isolate->factory()->NewStringFromAsciiChecked("2"), 1,
        Handle<Smi>(Smi::FromInt(4), isolate), BinaryOperationFeedback::kAny},
       // SAR
       {Token::Value::SAR, Handle<Smi>(Smi::FromInt(3), isolate), 1,
        Handle<Smi>(Smi::FromInt(1), isolate),
        BinaryOperationFeedback::kSignedSmall},
       {Token::Value::SAR, isolate->factory()->NewHeapNumber(3.1415), 2,
-       Handle<Smi>(Smi::kZero, isolate), BinaryOperationFeedback::kNumber},
+       Handle<Smi>(Smi::FromInt(0), isolate), BinaryOperationFeedback::kNumber},
       {Token::Value::SAR, isolate->factory()->NewStringFromAsciiChecked("2"), 1,
        Handle<Smi>(Smi::FromInt(1), isolate), BinaryOperationFeedback::kAny}};
 
   for (const BinaryOpExpectation& test_case : kTestCases) {
     BytecodeArrayBuilder builder(isolate, handles.main_zone(), 1, 0, 1);
 
     i::FeedbackVectorSpec feedback_spec(&zone);
     i::FeedbackVectorSlot slot0 = feedback_spec.AddInterpreterBinaryOpICSlot();
 
     Handle<i::TypeFeedbackVector> vector =
@@ skipping 659 matching lines @@
   FeedbackVectorSlot slot = feedback_spec.AddInterpreterBinaryOpICSlot();
   FeedbackVectorSlot slot1 = feedback_spec.AddInterpreterBinaryOpICSlot();
   FeedbackVectorSlot slot2 = feedback_spec.AddInterpreterBinaryOpICSlot();
 
   Handle<i::TypeFeedbackVector> vector =
       NewTypeFeedbackVector(isolate, &feedback_spec);
 
   Register reg(0), scratch(1);
   BytecodeLabel label[3];
 
-  builder.LoadLiteral(Smi::kZero)
+  builder.LoadLiteral(Smi::FromInt(0))
       .StoreAccumulatorInRegister(reg)
       .Jump(&label[1]);
   SetRegister(builder, reg, 1024, scratch).Bind(&label[0]);
   IncrementRegister(builder, reg, 1, scratch, vector->GetIndex(slot))
       .Jump(&label[2]);
   SetRegister(builder, reg, 2048, scratch).Bind(&label[1]);
   IncrementRegister(builder, reg, 2, scratch, vector->GetIndex(slot1))
       .JumpLoop(&label[0], 0);
   SetRegister(builder, reg, 4096, scratch).Bind(&label[2]);
   IncrementRegister(builder, reg, 4, scratch, vector->GetIndex(slot2))
@@ skipping 21 matching lines @@
   FeedbackVectorSlot slot3 = feedback_spec.AddInterpreterBinaryOpICSlot();
   FeedbackVectorSlot slot4 = feedback_spec.AddInterpreterBinaryOpICSlot();
 
   Handle<i::TypeFeedbackVector> vector =
       NewTypeFeedbackVector(isolate, &feedback_spec);
 
   Register reg(0), scratch(1);
   BytecodeLabel label[2];
   BytecodeLabel done, done1;
 
-  builder.LoadLiteral(Smi::kZero)
+  builder.LoadLiteral(Smi::FromInt(0))
       .StoreAccumulatorInRegister(reg)
       .LoadFalse()
       .JumpIfFalse(&label[0]);
   IncrementRegister(builder, reg, 1024, scratch, vector->GetIndex(slot))
       .Bind(&label[0])
       .LoadTrue()
       .JumpIfFalse(&done);
   IncrementRegister(builder, reg, 1, scratch, vector->GetIndex(slot1))
       .LoadTrue()
       .JumpIfTrue(&label[1]);
@@ skipping 29 matching lines @@
   FeedbackVectorSlot slot3 = feedback_spec.AddInterpreterBinaryOpICSlot();
   FeedbackVectorSlot slot4 = feedback_spec.AddInterpreterBinaryOpICSlot();
 
   Handle<i::TypeFeedbackVector> vector =
       NewTypeFeedbackVector(isolate, &feedback_spec);
 
   Register reg(0), scratch(1);
   BytecodeLabel label[2];
   BytecodeLabel done, done1;
 
-  builder.LoadLiteral(Smi::kZero)
+  builder.LoadLiteral(Smi::FromInt(0))
       .StoreAccumulatorInRegister(reg)
       .LoadFalse()
       .JumpIfFalse(&label[0]);
   IncrementRegister(builder, reg, 1024, scratch, vector->GetIndex(slot))
       .Bind(&label[0])
       .LoadTrue()
       .JumpIfFalse(&done);
   IncrementRegister(builder, reg, 1, scratch, vector->GetIndex(slot1))
       .LoadTrue()
       .JumpIfTrue(&label[1]);
@@ skipping 23 matching lines @@
   Zone zone(isolate->allocator());
 
   FeedbackVectorSpec feedback_spec(&zone);
   FeedbackVectorSlot slot = feedback_spec.AddInterpreterBinaryOpICSlot();
   Handle<i::TypeFeedbackVector> vector =
       NewTypeFeedbackVector(isolate, &feedback_spec);
 
   Register reg(0), scratch(256);
   BytecodeLabel done, fake;
 
-  builder.LoadLiteral(Smi::kZero);
+  builder.LoadLiteral(Smi::FromInt(0));
   builder.StoreAccumulatorInRegister(reg);
   // Consume all 8-bit operands
   for (int i = 1; i <= 256; i++) {
     builder.LoadLiteral(isolate->factory()->NewNumber(i));
     builder.BinaryOperation(Token::Value::ADD, reg, vector->GetIndex(slot));
     builder.StoreAccumulatorInRegister(reg);
   }
   builder.Jump(&done);
 
   // Emit more than 16-bit immediate operands worth of code to jump over.
   builder.Bind(&fake);
   for (int i = 0; i < 6600; i++) {
-    builder.LoadLiteral(Smi::kZero);  // 1-byte
+    builder.LoadLiteral(Smi::FromInt(0));                 // 1-byte
     builder.BinaryOperation(Token::Value::ADD, scratch,
                             vector->GetIndex(slot));      // 6-bytes
     builder.StoreAccumulatorInRegister(scratch);          // 4-bytes
     builder.MoveRegister(scratch, reg);                   // 6-bytes
   }
   builder.Bind(&done);
   builder.LoadAccumulatorWithRegister(reg);
   builder.Return();
 
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
@@ skipping 16 matching lines @@
   CHECK_EQ(Smi::cast(*return_value)->value(), 256.0 / 2 * (1 + 256));
 }
 
 TEST(InterpreterJumpWith32BitOperand) {
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
   BytecodeArrayBuilder builder(isolate, handles.main_zone(), 1, 0, 1);
   Register reg(0);
   BytecodeLabel done;
 
-  builder.LoadLiteral(Smi::kZero);
+  builder.LoadLiteral(Smi::FromInt(0));
   builder.StoreAccumulatorInRegister(reg);
   // Consume all 16-bit constant pool entries
   for (int i = 1; i <= 65536; i++) {
     builder.LoadLiteral(isolate->factory()->NewNumber(i));
   }
   builder.Jump(&done);
-  builder.LoadLiteral(Smi::kZero);
+  builder.LoadLiteral(Smi::FromInt(0));
   builder.Bind(&done);
   builder.Return();
 
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
   BytecodeArrayIterator iterator(bytecode_array);
 
   bool found_32bit_jump = false;
   while (!iterator.done()) {
     if (iterator.current_bytecode() == Bytecode::kJump &&
         iterator.current_operand_scale() == OperandScale::kQuadruple) {
@@ skipping 680 matching lines @@
       "function " +
       InterpreterTester::function_name() +
       "() {\n"
       "  var c = new counter();\n"
       "  return c.count;\n"
       "}");
   InterpreterTester tester(isolate, source.c_str());
   auto callable = tester.GetCallable<>();
 
   Handle<Object> return_val = callable().ToHandleChecked();
-  CHECK_EQ(Smi::cast(*return_val), Smi::kZero);
+  CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(0));
 }
 
 
 TEST(InterpreterConstructWithArgument) {
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
 
   std::string source(
       "function counter(arg0) { this.count = 17; this.x = arg0; }\n"
       "function " +
@@ skipping 192 matching lines @@
 
 TEST(InterpreterLogicalAnd) {
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
   Factory* factory = isolate->factory();
 
   std::pair<const char*, Handle<Object>> literals[] = {
       std::make_pair("var a, b = 10; return a && b;\n",
                      factory->undefined_value()),
       std::make_pair("var a = 0, b = 10; return a && b / a;\n",
-                     handle(Smi::kZero, isolate)),
+                     handle(Smi::FromInt(0), isolate)),
       std::make_pair("var a = '0', b = 10; return a && b;\n",
                      handle(Smi::FromInt(10), isolate)),
-      std::make_pair("return 0.0 && 3.2;\n", handle(Smi::kZero, isolate)),
+      std::make_pair("return 0.0 && 3.2;\n", handle(Smi::FromInt(0), isolate)),
       std::make_pair("return 'a' && 'b';\n",
                      factory->NewStringFromStaticChars("b")),
       std::make_pair("return 'a' && 0 || 'b', 'c';\n",
                      factory->NewStringFromStaticChars("c")),
       std::make_pair("var x = 1, y = 3; return x && 0 + 1 || y;\n",
                      handle(Smi::FromInt(1), isolate)),
       std::make_pair("var x = 1, y = 3; return (x == 1) && (3 == 3) || y;\n",
                      factory->true_value())};
 
   for (size_t i = 0; i < arraysize(literals); i++) {
@@ skipping 131 matching lines @@
 
   std::pair<const char*, Handle<Object>> count_ops[] = {
       std::make_pair("var a = 1; return ++a;",
                      handle(Smi::FromInt(2), isolate)),
       std::make_pair("var a = 1; return a++;",
                      handle(Smi::FromInt(1), isolate)),
       std::make_pair("var a = 5; return --a;",
                      handle(Smi::FromInt(4), isolate)),
       std::make_pair("var a = 5; return a--;",
                      handle(Smi::FromInt(5), isolate)),
-      std::make_pair("var a = 5.2; return --a;", factory->NewHeapNumber(4.2)),
-      std::make_pair("var a = 'string'; return ++a;", factory->nan_value()),
-      std::make_pair("var a = 'string'; return a--;", factory->nan_value()),
+      std::make_pair("var a = 5.2; return --a;",
+                     factory->NewHeapNumber(4.2)),
+      std::make_pair("var a = 'string'; return ++a;",
+                     factory->nan_value()),
+      std::make_pair("var a = 'string'; return a--;",
+                     factory->nan_value()),
       std::make_pair("var a = true; return ++a;",
                      handle(Smi::FromInt(2), isolate)),
-      std::make_pair("var a = false; return a--;", handle(Smi::kZero, isolate)),
+      std::make_pair("var a = false; return a--;",
+                     handle(Smi::FromInt(0), isolate)),
       std::make_pair("var a = { val: 11 }; return ++a.val;",
                      handle(Smi::FromInt(12), isolate)),
       std::make_pair("var a = { val: 11 }; return a.val--;",
                      handle(Smi::FromInt(11), isolate)),
       std::make_pair("var a = { val: 11 }; return ++a.val;",
                      handle(Smi::FromInt(12), isolate)),
       std::make_pair("var name = 'val'; var a = { val: 22 }; return --a[name];",
                      handle(Smi::FromInt(21), isolate)),
       std::make_pair("var name = 'val'; var a = { val: 22 }; return a[name]++;",
                      handle(Smi::FromInt(22), isolate)),
       std::make_pair("var a = 1; (function() { a = 2 })(); return ++a;",
                      handle(Smi::FromInt(3), isolate)),
       std::make_pair("var a = 1; (function() { a = 2 })(); return a--;",
                      handle(Smi::FromInt(2), isolate)),
       std::make_pair("var i = 5; while(i--) {}; return i;",
                      handle(Smi::FromInt(-1), isolate)),
       std::make_pair("var i = 1; if(i--) { return 1; } else { return 2; };",
                      handle(Smi::FromInt(1), isolate)),
       std::make_pair("var i = -2; do {} while(i++) {}; return i;",
-                     handle(Smi::FromInt(1), isolate)),
+                      handle(Smi::FromInt(1), isolate)),
       std::make_pair("var i = -1; for(; i++; ) {}; return i",
-                     handle(Smi::FromInt(1), isolate)),
+                      handle(Smi::FromInt(1), isolate)),
       std::make_pair("var i = 20; switch(i++) {\n"
                      "  case 20: return 1;\n"
                      "  default: return 2;\n"
                      "}",
                      handle(Smi::FromInt(1), isolate)),
   };
 
   for (size_t i = 0; i < arraysize(count_ops); i++) {
     std::string source(InterpreterTester::SourceForBody(count_ops[i].first));
     InterpreterTester tester(isolate, source.c_str());
@@ skipping 1160 matching lines @@
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
 
   const char* inner_function_prologue = "function inner() {";
   const char* inner_function_epilogue = "};";
   const char* outer_function_epilogue = "return inner();";
 
   std::tuple<const char*, const char*, Handle<Object>> lookup_slot[] = {
       // Eval in inner context.
       std::make_tuple("var x = 0;", "eval(''); return x;",
-                      handle(Smi::kZero, isolate)),
+                      handle(Smi::FromInt(0), isolate)),
       std::make_tuple("var x = 0;", "eval('var x = 1'); return x;",
                       handle(Smi::FromInt(1), isolate)),
       std::make_tuple("var x = 0;",
                       "'use strict'; eval('var x = 1'); return x;",
-                      handle(Smi::kZero, isolate)),
+                      handle(Smi::FromInt(0), isolate)),
       // Eval in outer context.
       std::make_tuple("var x = 0; eval('');", "return x;",
-                      handle(Smi::kZero, isolate)),
+                      handle(Smi::FromInt(0), isolate)),
       std::make_tuple("var x = 0; eval('var x = 1');", "return x;",
                       handle(Smi::FromInt(1), isolate)),
       std::make_tuple("'use strict'; var x = 0; eval('var x = 1');",
-                      "return x;", handle(Smi::kZero, isolate)),
+                      "return x;", handle(Smi::FromInt(0), isolate)),
   };
 
   for (size_t i = 0; i < arraysize(lookup_slot); i++) {
     std::string body = std::string(std::get<0>(lookup_slot[i])) +
                        std::string(inner_function_prologue) +
                        std::string(std::get<1>(lookup_slot[i])) +
                        std::string(inner_function_epilogue) +
                        std::string(outer_function_epilogue);
     std::string script = InterpreterTester::SourceForBody(body.c_str());
 
     InterpreterTester tester(isolate, script.c_str());
     auto callable = tester.GetCallable<>();
 
     Handle<i::Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*std::get<2>(lookup_slot[i])));
   }
 }
 
 TEST(InterpreterLookupGlobalSlot) {
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
 
   const char* inner_function_prologue = "function inner() {";
   const char* inner_function_epilogue = "};";
   const char* outer_function_epilogue = "return inner();";
 
   std::tuple<const char*, const char*, Handle<Object>> lookup_slot[] = {
       // Eval in inner context.
       std::make_tuple("x = 0;", "eval(''); return x;",
-                      handle(Smi::kZero, isolate)),
+                      handle(Smi::FromInt(0), isolate)),
       std::make_tuple("x = 0;", "eval('var x = 1'); return x;",
                       handle(Smi::FromInt(1), isolate)),
       std::make_tuple("x = 0;", "'use strict'; eval('var x = 1'); return x;",
-                      handle(Smi::kZero, isolate)),
+                      handle(Smi::FromInt(0), isolate)),
       // Eval in outer context.
       std::make_tuple("x = 0; eval('');", "return x;",
-                      handle(Smi::kZero, isolate)),
+                      handle(Smi::FromInt(0), isolate)),
       std::make_tuple("x = 0; eval('var x = 1');", "return x;",
                       handle(Smi::FromInt(1), isolate)),
       std::make_tuple("'use strict'; x = 0; eval('var x = 1');", "return x;",
-                      handle(Smi::kZero, isolate)),
+                      handle(Smi::FromInt(0), isolate)),
   };
 
   for (size_t i = 0; i < arraysize(lookup_slot); i++) {
     std::string body = std::string(std::get<0>(lookup_slot[i])) +
                        std::string(inner_function_prologue) +
                        std::string(std::get<1>(lookup_slot[i])) +
                        std::string(inner_function_epilogue) +
                        std::string(outer_function_epilogue);
     std::string script = InterpreterTester::SourceForBody(body.c_str());
 
@@ skipping 863 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