[crankshaft] Re-add fast-case for string add left/right.

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/allocation-site-scopes.h"
 #include "src/ast-numbering.h"
@@ skipping 10996 matching lines @@
       if (right_type->Is(Type::String())) {
         right = BuildCheckString(right);
       }
 
       // Convert left argument as necessary.
       if (left_type->Is(Type::Number())) {
         DCHECK(right_type->Is(Type::String()));
         left = BuildNumberToString(left, left_type);
       } else if (!left_type->Is(Type::String())) {
         DCHECK(right_type->Is(Type::String()));
-        // TODO(bmeurer): We might want to optimize this, because we already
-        // know that the right hand side is a string.
-        Add<HPushArguments>(left, right);
-        return AddUncasted<HCallRuntime>(Runtime::FunctionForId(Runtime::kAdd),
-                                         2);
+        return AddUncasted<HStringAdd>(
+            left, right, allocation_mode.GetPretenureMode(),
+            STRING_ADD_CONVERT_LEFT, allocation_mode.feedback_site());
       }
 
       // Convert right argument as necessary.
       if (right_type->Is(Type::Number())) {
         DCHECK(left_type->Is(Type::String()));
         right = BuildNumberToString(right, right_type);
       } else if (!right_type->Is(Type::String())) {
         DCHECK(left_type->Is(Type::String()));
-        // TODO(bmeurer): We might want to optimize this, because we already
-        // know that the left hand side is a string.
-        Add<HPushArguments>(left, right);
-        return AddUncasted<HCallRuntime>(Runtime::FunctionForId(Runtime::kAdd),
-                                         2);
+        return AddUncasted<HStringAdd>(
+            left, right, allocation_mode.GetPretenureMode(),
+            STRING_ADD_CONVERT_RIGHT, allocation_mode.feedback_site());
       }
     }
 
     // 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()
             : Handle<String>();
     if (!left_string.is_null() && left_string->length() == 0) return right;
     if (!right_string.is_null() && right_string->length() == 0) return left;
     if (!left_string.is_null() && !right_string.is_null()) {
       return AddUncasted<HStringAdd>(
-          left, right, strength, allocation_mode.GetPretenureMode(),
+          left, right, allocation_mode.GetPretenureMode(),
           STRING_ADD_CHECK_NONE, allocation_mode.feedback_site());
     }
 
     // Register the dependent code with the allocation site.
     if (!allocation_mode.feedback_site().is_null()) {
       DCHECK(!graph()->info()->IsStub());
       Handle<AllocationSite> site(allocation_mode.feedback_site());
       top_info()->dependencies()->AssumeTenuringDecision(site);
     }
 
     // Inline the string addition into the stub when creating allocation
     // mementos to gather allocation site feedback, or if we can statically
     // infer that we're going to create a cons string.
     if ((graph()->info()->IsStub() &&
          allocation_mode.CreateAllocationMementos()) ||
         (left->IsConstant() &&
          HConstant::cast(left)->HasStringValue() &&
          HConstant::cast(left)->StringValue()->length() + 1 >=
            ConsString::kMinLength) ||
         (right->IsConstant() &&
          HConstant::cast(right)->HasStringValue() &&
          HConstant::cast(right)->StringValue()->length() + 1 >=
            ConsString::kMinLength)) {
       return BuildStringAdd(left, right, allocation_mode);
     }
 
     // Fallback to using the string add stub.
     return AddUncasted<HStringAdd>(
-        left, right, strength, allocation_mode.GetPretenureMode(),
-        STRING_ADD_CHECK_NONE, allocation_mode.feedback_site());
+        left, right, allocation_mode.GetPretenureMode(), STRING_ADD_CHECK_NONE,
+        allocation_mode.feedback_site());
   }
 
   if (graph()->info()->IsStub()) {
     left = EnforceNumberType(left, left_type);
     right = EnforceNumberType(right, right_type);
   }
 
   Representation result_rep = RepresentationFor(result_type);
 
   bool is_non_primitive = (left_rep.IsTagged() && !left_rep.IsSmi()) ||
@@ skipping 1437 matching lines @@
 }
 
 
 // Fast support for StringAdd.
 void HOptimizedGraphBuilder::GenerateStringAdd(CallRuntime* call) {
   DCHECK_EQ(2, call->arguments()->length());
   CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
   CHECK_ALIVE(VisitForValue(call->arguments()->at(1)));
   HValue* right = Pop();
   HValue* left = Pop();
-  HInstruction* result =
-      NewUncasted<HStringAdd>(left, right, strength(function_language_mode()));
+  HInstruction* result = NewUncasted<HStringAdd>(left, right);
   return ast_context()->ReturnInstruction(result, call->id());
 }
 
 
 // Fast support for SubString.
 void HOptimizedGraphBuilder::GenerateSubString(CallRuntime* call) {
   DCHECK_EQ(3, call->arguments()->length());
   CHECK_ALIVE(VisitExpressions(call->arguments()));
   PushArgumentsFromEnvironment(call->arguments()->length());
   HCallStub* result = New<HCallStub>(CodeStub::SubString, 3);
@@ skipping 1057 matching lines @@
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 }  // namespace internal
 }  // namespace v8