[strong] Simplify (and sortof optimize) string addition for strong mode.

src/hydrogen.cc

 // Copyright 2013 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/hydrogen.h"
 
 #include <sstream>
 
 #include "src/v8.h"
 
@@ skipping 10886 matching lines @@
 
   if (!maybe_string_add && !is_strong(strength)) {
     left = TruncateToNumber(left, &left_type);
     right = TruncateToNumber(right, &right_type);
   }
 
   // Special case for string addition here.
   if (op == Token::ADD &&
       (left_type->Is(Type::String()) || right_type->Is(Type::String()))) {
     // Validate type feedback for left argument.
     if (left_type->Is(Type::String())) {

[Jarin, 2015/08/13 06:23:51]

Could not you say here 

if (left_type->Is(Type::String()) || is_strong(strength)) {
  left = BuildCheckString(left);
} 

And then below say

if (!left_type->Is(Type::String()) && !is_strong(strength)) {
  DCHECK(right_type->Is(Type::String()));
  if (left_type->Is(Type::Number())) {
    ...

[Benedikt Meurer, 2015/08/13 06:31:13]

Restructured to simplify strong case as per offline discussion.

       left = BuildCheckString(left);
     }
 
     // Validate type feedback for right argument.
     if (right_type->Is(Type::String())) {
       right = BuildCheckString(right);
     }
 
     // Convert left argument as necessary.
-    if (left_type->Is(Type::Number()) && !is_strong(strength)) {
+    if (!left_type->Is(Type::String())) {
       DCHECK(right_type->Is(Type::String()));
-      left = BuildNumberToString(left, left_type);
-    } else if (!left_type->Is(Type::String())) {
-      DCHECK(right_type->Is(Type::String()));
-      HValue* function = AddLoadJSBuiltin(
-          is_strong(strength) ? Builtins::STRING_ADD_RIGHT_STRONG
-                              : Builtins::STRING_ADD_RIGHT);
-      Add<HPushArguments>(left, right);
-      return AddUncasted<HInvokeFunction>(function, 2);
+      if (is_strong(strength)) {
+        // In strong mode, if the left hand side of an additition is a string,

[Jarin, 2015/08/13 06:23:50]

additition -> addition (Here and below.)

[Benedikt Meurer, 2015/08/13 06:31:13]

Done.

+        // the right hand side must be a string too.
+        left = BuildCheckString(left);
+      } else if (left_type->Is(Type::Number())) {
+        left = BuildNumberToString(left, left_type);
+      } else {
+        HValue* function = AddLoadJSBuiltin(Builtins::STRING_ADD_RIGHT);
+        Add<HPushArguments>(left, right);
+        return AddUncasted<HInvokeFunction>(function, 2);
+      }
     }
 
     // Convert right argument as necessary.
-    if (right_type->Is(Type::Number()) && !is_strong(strength)) {
+    if (!right_type->Is(Type::String())) {
       DCHECK(left_type->Is(Type::String()));
-      right = BuildNumberToString(right, right_type);
-    } else if (!right_type->Is(Type::String())) {
-      DCHECK(left_type->Is(Type::String()));
-      HValue* function = AddLoadJSBuiltin(is_strong(strength)
-                                              ? Builtins::STRING_ADD_LEFT_STRONG
-                                              : Builtins::STRING_ADD_LEFT);
-      Add<HPushArguments>(left, right);
-      return AddUncasted<HInvokeFunction>(function, 2);
+      if (is_strong(strength)) {
+        // In strong mode, if the right hand side of an additition is a string,
+        // the left hand side must be a string too.
+        right = BuildCheckString(right);
+      } else if (right_type->Is(Type::Number())) {
+        right = BuildNumberToString(right, right_type);
+      } else {
+        HValue* function = AddLoadJSBuiltin(Builtins::STRING_ADD_LEFT);
+        Add<HPushArguments>(left, right);
+        return AddUncasted<HInvokeFunction>(function, 2);
+      }
     }
 
     // Fast paths for empty constant strings.
     Handle<String> left_string =
         left->IsConstant() && HConstant::cast(left)->HasStringValue()
             ? HConstant::cast(left)->StringValue()
             : Handle<String>();
     Handle<String> right_string =
         right->IsConstant() && HConstant::cast(right)->HasStringValue()
             ? HConstant::cast(right)->StringValue()
@@ skipping 2482 matching lines @@
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 }  // namespace internal
 }  // namespace v8