Hydrogenisation of binops

src/code-stubs.cc

Index: src/code-stubs.cc
diff --git a/src/code-stubs.cc b/src/code-stubs.cc
index ace4af42a9e0797723a242e8873c8ab9d7825a50..e2505994e25daf470e3865c1bd95d0af1ed5813c 100644
--- a/src/code-stubs.cc
+++ b/src/code-stubs.cc
@@ -137,6 +137,7 @@ Handle<Code> CodeStub::GetCode(Isolate* isolate) {
       ? FindCodeInSpecialCache(&code, isolate)
       : FindCodeInCache(&code, isolate)) {
     ASSERT(IsPregenerated(isolate) == code->is_pregenerated());
+    ASSERT(GetCodeKind() == code->kind());
     return Handle<Code>(code);
   }
 
@@ -203,119 +204,310 @@ void CodeStub::PrintName(StringStream* stream) {
 }
 
 
-void BinaryOpStub::Generate(MacroAssembler* masm) {
-  // Explicitly allow generation of nested stubs. It is safe here because
-  // generation code does not use any raw pointers.
-  AllowStubCallsScope allow_stub_calls(masm, true);
+void BinaryOpStub::PrintBaseName(StringStream* stream) {
+  const char* op_name = Token::Name(op_);
+  stream->Add("BinaryOpStub_%s",
+              op_name);
+}
+
 
-  BinaryOpIC::TypeInfo operands_type = Max(left_type_, right_type_);
-  if (left_type_ == BinaryOpIC::ODDBALL && right_type_ == BinaryOpIC::ODDBALL) {
-    // The OddballStub handles a number and an oddball, not two oddballs.
-    operands_type = BinaryOpIC::GENERIC;
+void BinaryOpStub::PrintState(StringStream* stream) {
+  stream->Add("(");
+  stream->Add(StateToName(left_state_));
+  if (left_oddball_state_ != NO_ODDBALL) {
+    stream->Add(",");
+    stream->Add(OddballStateToName(left_oddball_state_));
   }
-  switch (operands_type) {
-    case BinaryOpIC::UNINITIALIZED:
-      GenerateTypeTransition(masm);
-      break;
-    case BinaryOpIC::SMI:
-      GenerateSmiStub(masm);
-      break;
-    case BinaryOpIC::INT32:
-      GenerateInt32Stub(masm);
-      break;
-    case BinaryOpIC::NUMBER:
-      GenerateNumberStub(masm);
-      break;
-    case BinaryOpIC::ODDBALL:
-      GenerateOddballStub(masm);
-      break;
-    case BinaryOpIC::STRING:
-      GenerateStringStub(masm);
-      break;
-    case BinaryOpIC::GENERIC:
-      GenerateGeneric(masm);
-      break;
+  stream->Add("*");
+  if (fixed_right_arg_.has_value) {
+    stream->Add("%d", fixed_right_arg_.value);
+  } else {
+    stream->Add(StateToName(right_state_));
+    if (right_oddball_state_ != NO_ODDBALL) {
+      stream->Add(",");
+      stream->Add(OddballStateToName(right_oddball_state_));
+    }
+  }
+  stream->Add("->");
+  stream->Add(StateToName(result_state_));
+  stream->Add(")");
+}
+
+
+Maybe<Handle<Object> > BinaryOpStub::Result(Handle<Object> left,
+                                            Handle<Object> right,
+                                            Isolate* isolate) {
+  Handle<JSBuiltinsObject> builtins(isolate->js_builtins_object());
+  Builtins::JavaScript func = BinaryOpIC::TokenToJSBuiltin(op_);
+  Object* builtin = builtins->javascript_builtin(func);
+  Handle<JSFunction> builtin_function =
+      Handle<JSFunction>(JSFunction::cast(builtin), isolate);
+  bool caught_exception;
+  Handle<Object> result = Execution::Call(isolate, builtin_function, left,
+      1, &right, &caught_exception);
+  return Maybe<Handle<Object> >(!caught_exception, result);
+}
+
+
+void BinaryOpStub::init() {
+  fixed_right_arg_.has_value = false;
+  left_state_ = right_state_ = result_state_ = NONE;
+  left_oddball_state_ = right_oddball_state_ = NO_ODDBALL;
+}
+
+
+void BinaryOpStub::GenerateAheadOfTimeAllOps(Isolate* isolate,
+                                             BinaryOpStub stub) {
+  Token::Value binop[] = {Token::SUB, Token::MOD, Token::DIV, Token::MUL,
+                          Token::ADD, Token::SAR, Token::BIT_OR, Token::BIT_AND,
+                          Token::BIT_XOR, Token::SHL, Token::SHR};
+  for (int i = 0; i < 11; i++) {
+    // Bitwise operations cannot return heap numbers.
+    if (i > 5 && stub.result_state_ > INT32) continue;
+    // TODO(olivf) NumberTagU is not snapshot safe yet so we have to skip SHR
+    // since that produces a unsigned int32.
+    if (binop[i] == Token::SHR && stub.result_state_ > SMI) continue;
+
+    stub.op_ = binop[i];
+    stub.GetCode(isolate);
+  }
+}
+
+
+void BinaryOpStub::GenerateAheadOfTime(Isolate* isolate) {
+  BinaryOpStub unint_stub(UNINITIALIZED);
+  GenerateAheadOfTimeAllOps(isolate, unint_stub);
+
+  BinaryOpStub stub(INITIALIZED);
+  for (int left = SMI; left <= NUMBER; left++) {
+    stub.left_state_ = static_cast<State>(left);
+    for (int right = SMI; right <= NUMBER; right++) {
+      stub.right_state_ = static_cast<State>(right);
+      for (int res = SMI; res <= NUMBER; res++) {
+        stub.result_state_ = static_cast<State>(res);
+        GenerateAheadOfTimeAllOps(isolate, stub);
+      }
+    }
+  }
+  stub.left_state_ = STRING;
+  stub.right_state_ = STRING;
+  stub.result_state_ = STRING;
+  stub.op_ = Token::ADD;
+  stub.GetCode(isolate);
+}
+
+
+bool BinaryOpStub::can_encode_arg_value(int32_t value) const {
+  return op_ == Token::MOD && value > 0 && IsPowerOf2(value) &&
+         FixedRightArgValueBits::is_valid(WhichPowerOf2(value));
+}
+
+
+int BinaryOpStub::encode_arg_value(int32_t value) const {
+  ASSERT(can_encode_arg_value(value));
+  return WhichPowerOf2(value);
+}
+
+
+int32_t BinaryOpStub::decode_arg_value(int value)  const {
+  return 1 << value;
+}
+
+
+int BinaryOpStub::encode_token(Token::Value op) const {
+  ASSERT(op >= FIRST_TOKEN && op <= LAST_TOKEN);
+  return op - FIRST_TOKEN;
+}
+
+
+Token::Value BinaryOpStub::decode_token(int op) const {
+  int res = op + FIRST_TOKEN;
+  ASSERT(res >= FIRST_TOKEN && res <= LAST_TOKEN);
+  return static_cast<Token::Value>(res);
+}
+
+
+const char* BinaryOpStub::StateToName(State state) {
+  switch (state) {
     default:
       UNREACHABLE();
+    case NONE:
+      return "None";
+    case SMI:
+      return "Smi";
+    case INT32:
+      return "Int32";
+    case NUMBER:
+      return "Number";
+    case STRING:
+      return "String";
+    case GENERIC:
+      return "Generic";
   }
 }
 
 
-#define __ ACCESS_MASM(masm)
+const char* BinaryOpStub::OddballStateToName(OddballState state) {
+  switch (state) {
+    default:
+      UNREACHABLE();
+    case NO_ODDBALL:
+      return "None";
+    case BOOLEAN:
+      return "Boolean";
+    case NULL_VALUE:
+      return "Undefined";
+    case BOOLEN_AND_NULL:
+      return "Boolean,Null";
+  }
+}
 
 
-void BinaryOpStub::GenerateCallRuntime(MacroAssembler* masm) {
-  switch (op_) {
-    case Token::ADD:
-      __ InvokeBuiltin(Builtins::ADD, CALL_FUNCTION);
-      break;
-    case Token::SUB:
-      __ InvokeBuiltin(Builtins::SUB, CALL_FUNCTION);
-      break;
-    case Token::MUL:
-      __ InvokeBuiltin(Builtins::MUL, CALL_FUNCTION);
+void BinaryOpStub::UpdateStatus(Handle<Object> left,
+                                Handle<Object> right,
+                                Maybe<Handle<Object> > result) {
+  int old_state = GetExtraICState();
+
+  UpdateStatus(left, &left_state_, &left_oddball_state_);
+  UpdateStatus(right, &right_state_, &right_oddball_state_);
+
+  int32_t value;
+  bool new_has_fixed_right_arg =
+      right->ToInt32(&value) && can_encode_arg_value(value) &&
+      (left_state_ == SMI || left_state_ == INT32) &&
+      (result_state_ == NONE || !fixed_right_arg_.has_value);
+
+  fixed_right_arg_ = Maybe<int32_t>(new_has_fixed_right_arg, value);
+
+  if (result.has_value) UpdateStatus(result.value, &result_state_);
+
+  State max_result = has_int_result() ? INT32 : NUMBER;
+  State max_input = Max(left_state_, right_state_);
+
+  // Avoid unnecessary Representation changes.
+  if (left_state_ == STRING && right_state_ < STRING) {
+    right_state_ = GENERIC;
+  } else if (right_state_ == STRING && left_state_ < STRING) {
+    left_state_ = GENERIC;
+  } else if ((right_state_ == GENERIC && left_state_ != STRING) ||
+             (left_state_ == GENERIC && right_state_ != STRING)) {
+    left_state_ = right_state_ = GENERIC;
+  } else if (max_input <= NUMBER && max_input > result_state_) {
+    result_state_ = Min(max_result, max_input);
+  }
+
+  ASSERT(result_state_ <= max_result || op_ == Token::ADD);
+
+  if (old_state == GetExtraICState()) {
+    // Since the fpu is to precise, we might bail out on numbers which
+    // actually would truncate with 64 bit precision.
+    ASSERT(!CpuFeatures::IsSupported(SSE2) &&
+           result_state_ <= INT32);
+    result_state_ = NUMBER;
+  }
+}
+
+
+void BinaryOpStub::UpdateStatus(Handle<Object> object,
+                                State* state,
+                                OddballState* oddball_state) {
+  v8::internal::TypeInfo type = v8::internal::TypeInfo::FromValue(object);
+  if (object->IsUndefined()) {
+    // Undefined will be automatically truncated for us by HChange.
+    type = (op_ == Token::BIT_AND || op_ == Token::BIT_OR ||
+            op_ == Token::BIT_XOR || op_ == Token::SAR ||
+            op_ == Token::SHL || op_ == Token::SHR)
+      ? TypeInfo::Integer32()
+      : TypeInfo::Double();
+  }
+  State int_state = SmiValuesAre32Bits() ? NUMBER : INT32;
+  if (type.IsSmi() && *state <= SMI) {
+    *state = SMI;
+  } else if (type.IsInteger32() && *state <= int_state) {
+    *state = int_state;
+  } else if (type.IsNumber() && *state <= NUMBER) {
+    *state = NUMBER;
+  } else if (object->IsString() && operation() == Token::ADD &&
+             (*state == NONE || *state == STRING)) {
+    *state = STRING;
+  } else if (object->IsNull()) {
+    ASSERT(oddball_state != NULL);
+    *oddball_state = (*oddball_state == NO_ODDBALL ||
+                      *oddball_state == NULL_VALUE)
+      ? NULL_VALUE : BOOLEN_AND_NULL;
+  } else if (object->IsBoolean()) {
+    ASSERT(oddball_state != NULL);
+    *oddball_state = (*oddball_state == NO_ODDBALL ||
+                      *oddball_state == BOOLEAN)
+      ? BOOLEAN : BOOLEN_AND_NULL;
+  } else {
+    *state = GENERIC;
+  }
+}
+
+
+Handle<Type> BinaryOpStub::StateToType(State state,
+                                       OddballState oddball_state,
+                                       Isolate* isolate) {
+  Handle<Type> t = handle(Type::None(), isolate);
+  switch (state) {
+    case NUMBER:
+      t = handle(Type::Union(t, handle(Type::Number(), isolate)), isolate);
       break;
-    case Token::DIV:
-      __ InvokeBuiltin(Builtins::DIV, CALL_FUNCTION);
+    case INT32:
+      t = handle(Type::Union(t, handle(Type::Signed32(), isolate)), isolate);
       break;
-    case Token::MOD:
-      __ InvokeBuiltin(Builtins::MOD, CALL_FUNCTION);
+    case SMI:
+      t = handle(Type::Union(t, handle(Type::Smi(), isolate)), isolate);
       break;
-    case Token::BIT_OR:
-      __ InvokeBuiltin(Builtins::BIT_OR, CALL_FUNCTION);
+
+    case STRING:
+      t = handle(Type::Union(t, handle(Type::String(), isolate)), isolate);
       break;
-    case Token::BIT_AND:
-      __ InvokeBuiltin(Builtins::BIT_AND, CALL_FUNCTION);
+    case GENERIC:
+      return handle(Type::Any(), isolate);
       break;
-    case Token::BIT_XOR:
-      __ InvokeBuiltin(Builtins::BIT_XOR, CALL_FUNCTION);
+    case NONE:
       break;
-    case Token::SAR:
-      __ InvokeBuiltin(Builtins::SAR, CALL_FUNCTION);
+  }
+  switch (oddball_state) {
+    case NULL_VALUE:
+      t = handle(Type::Union(t, handle(Type::Null(), isolate)), isolate);
       break;
-    case Token::SHR:
-      __ InvokeBuiltin(Builtins::SHR, CALL_FUNCTION);
+    case BOOLEN_AND_NULL:
+      t = handle(Type::Union(t, handle(Type::Null(), isolate)), isolate);
+      // Fall through.
+    case BOOLEAN:
+      t = handle(Type::Union(t, handle(Type::Boolean(), isolate)), isolate);
       break;
-    case Token::SHL:
-      __ InvokeBuiltin(Builtins::SHL, CALL_FUNCTION);
+    case NO_ODDBALL:
       break;
-    default:
-      UNREACHABLE();
   }
+  return t;
 }
 
 
-#undef __
+Handle<Type> BinaryOpStub::GetLeftType(Isolate* isolate) const {
+  return StateToType(left_state_, left_oddball_state_, isolate);
+}
 
 
-void BinaryOpStub::PrintName(StringStream* stream) {
-  const char* op_name = Token::Name(op_);
-  const char* overwrite_name;
-  switch (mode_) {
-    case NO_OVERWRITE: overwrite_name = "Alloc"; break;
-    case OVERWRITE_RIGHT: overwrite_name = "OverwriteRight"; break;
-    case OVERWRITE_LEFT: overwrite_name = "OverwriteLeft"; break;
-    default: overwrite_name = "UnknownOverwrite"; break;
-  }
-  stream->Add("BinaryOpStub_%s_%s_%s+%s",
-              op_name,
-              overwrite_name,
-              BinaryOpIC::GetName(left_type_),
-              BinaryOpIC::GetName(right_type_));
-}
-
-
-void BinaryOpStub::GenerateStringStub(MacroAssembler* masm) {
-  ASSERT(left_type_ == BinaryOpIC::STRING || right_type_ == BinaryOpIC::STRING);
-  ASSERT(op_ == Token::ADD);
-  if (left_type_ == BinaryOpIC::STRING && right_type_ == BinaryOpIC::STRING) {
-    GenerateBothStringStub(masm);
-    return;
-  }
-  // Try to add arguments as strings, otherwise, transition to the generic
-  // BinaryOpIC type.
-  GenerateAddStrings(masm);
-  GenerateTypeTransition(masm);
+Handle<Type> BinaryOpStub::GetRightType(Isolate* isolate) const {
+  return StateToType(right_state_, right_oddball_state_, isolate);
+}
+
+
+Handle<Type> BinaryOpStub::GetResultType(Isolate* isolate) const {
+  if (HasSideEffects(isolate)) return StateToType(NONE, NO_ODDBALL, isolate);
+  if (result_state_ == GENERIC && op_ == Token::ADD) {
+    return handle(Type::Union(handle(Type::Number(), isolate),
+                              handle(Type::String(), isolate)), isolate);
+  }
+  ASSERT(result_state_ != GENERIC);
+  if (result_state_ == NUMBER && op_ == Token::SHR) {
+    return handle(Type::Unsigned32(), isolate);
+  }
+  return StateToType(result_state_, NO_ODDBALL, isolate);
 }