Handle string + number in hydrogen.

src/hydrogen.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1265 matching lines @@
                               array_length, elements_length);
 
     if_builder.End();
   }
 
   Add<HStoreNamedField>(object, HObjectAccess::ForMap(), map);
 }
 
 
 HValue* HGraphBuilder::BuildLookupNumberStringCache(
-    HValue* object,
-    HIfContinuation* continuation) {
+    HValue* object, ToStringMode mode, HIfContinuation* continuation) {
   // Create a joinable continuation.
   HIfContinuation found(graph()->CreateBasicBlock(),
                         graph()->CreateBasicBlock());
 
   // Load the number string cache.
   HValue* number_string_cache =
       Add<HLoadRoot>(Heap::kNumberStringCacheRootIndex);
 
   // Make the hash maks from the length of the number string cache. It
   // contains two elements (number and string) for each cache entry.
@@ skipping 61 matching lines @@
             Add<HLoadNamedField>(key, HObjectAccess::ForHeapNumberValue()),
             Add<HLoadNamedField>(object, HObjectAccess::ForHeapNumberValue()),
             Token::EQ);
         if_keyeqobject.Then();
         {
           // Make the key_index available.
           Push(key_index);
         }
         if_keyeqobject.JoinContinuation(&found);
       }
+      if (mode == CHECK_NUMBER) {
+        if_objectisnumber.Else();
+        if_objectisnumber.Deopt("Expected Argument to be Numeric");
+      }
       if_keyisnumber.JoinContinuation(&found);
     }
     if_objectisnumber.JoinContinuation(&found);
   }
   if_objectissmi.End();
 
   // Check for cache hit.
   IfBuilder if_found(this, &found);
   if_found.Then();
 
   // Load the value in case of cache hit.
   HValue* key_index = Pop();
   HValue* value_index = Add<HAdd>(key_index, graph()->GetConstant1());
   HValue* value = AddFastElementAccess(number_string_cache, value_index,
                                       NULL, NULL, FAST_ELEMENTS, false,
                                       ALLOW_RETURN_HOLE, STANDARD_STORE);
   AddIncrementCounter(isolate()->counters()->number_to_string_native());
 
   if_found.CaptureContinuation(continuation);
 
   // The value is only available in true branch of continuation.
   return value;
 }
 
 
-HValue* HGraphBuilder::BuildNumberToString(HValue* number) {
+HValue* HGraphBuilder::BuildNumberToString(HValue* number, ToStringMode mode) {
   NoObservableSideEffectsScope scope(this);
 
   // Lookup the number in the number string cache.
   HIfContinuation continuation;
-  HValue* value = BuildLookupNumberStringCache(number, &continuation);
+  HValue* value = BuildLookupNumberStringCache(number, mode, &continuation);
   IfBuilder if_found(this, &continuation);
   if_found.Then();
 
   // Cache hit.
   Push(value);
 
   if_found.Else();
 
   // Cache miss, fallback to runtime.
   Add<HPushArgument>(number);
@@ skipping 6492 matching lines @@
   // operation in optimized code, which is more expensive, than a stub call.
   if (binop_stub && is_non_primitive && !is_string_add) {
     HValue* function = AddLoadJSBuiltin(BinaryOpIC::TokenToJSBuiltin(op));
     Add<HPushArgument>(left);
     Add<HPushArgument>(right);
     instr = NewUncasted<HInvokeFunction>(function, 2);
   } else {
     switch (op) {
       case Token::ADD:
         if (is_string_add) {
-          StringAddFlags flags = STRING_ADD_CHECK_BOTH;
+          StringAddFlags flags = STRING_ADD_CHECK_NONE;
           if (left_type->Is(Type::String())) {
             BuildCheckHeapObject(left);
             AddInstruction(HCheckInstanceType::NewIsString(left, zone()));
-            flags = STRING_ADD_CHECK_RIGHT;
+            if (right_type->Is(Type::Number())) {
+              right = BuildNumberToString(right, CHECK_NUMBER);
+            } else {
+              flags = STRING_ADD_CHECK_RIGHT;
+            }
           }
           if (right_type->Is(Type::String())) {
+            if (left_type->Is(Type::Number())) {
+              left = BuildNumberToString(left, CHECK_NUMBER);
+            } else {
+              flags = (flags == STRING_ADD_CHECK_RIGHT)
+                  ? STRING_ADD_CHECK_NONE : STRING_ADD_CHECK_LEFT;
+            }
             BuildCheckHeapObject(right);
             AddInstruction(HCheckInstanceType::NewIsString(right, zone()));
-            flags = (flags == STRING_ADD_CHECK_BOTH)
-                ? STRING_ADD_CHECK_LEFT : STRING_ADD_CHECK_NONE;
           }
           instr = NewUncasted<HStringAdd>(left, right, flags);
         } else {
           instr = NewUncasted<HAdd>(left, right);
         }
         break;
       case Token::SUB:
         instr = NewUncasted<HSub>(left, right);
         break;
       case Token::MUL:
@@ skipping 1184 matching lines @@
 void HOptimizedGraphBuilder::GenerateGetFromCache(CallRuntime* call) {
   return Bailout(kInlinedRuntimeFunctionGetFromCache);
 }
 
 
 // Fast support for number to string.
 void HOptimizedGraphBuilder::GenerateNumberToString(CallRuntime* call) {
   ASSERT_EQ(1, call->arguments()->length());
   CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
   HValue* number = Pop();
-  HValue* result = BuildNumberToString(number);
+  HValue* result = BuildNumberToString(number, ALLOW_SIDE_EFFECTS);
   return ast_context()->ReturnValue(result);
 }
 
 
 // Fast call for custom callbacks.
 void HOptimizedGraphBuilder::GenerateCallFunction(CallRuntime* call) {
   // 1 ~ The function to call is not itself an argument to the call.
   int arg_count = call->arguments()->length() - 1;
   ASSERT(arg_count >= 1);  // There's always at least a receiver.
 
@@ skipping 737 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal