Improves performance for calls from Crankshaft code to certain string and...

src/hydrogen.cc

 // Copyright 2012 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 1134 matching lines @@
     HPhi* phi = phi_list[i];
     if (!phi->is_live()) {
       HBasicBlock* block = phi->block();
       block->RemovePhi(phi);
       block->RecordDeletedPhi(phi->merged_index());
     }
   }
 }
 
 
+void HGraph::OptimizeStringCalls() {
+  HPhase phase("Optimize string calls", this);
+
+  Handle<JSBuiltinsObject> builtins(
+    start_environment_->closure()->context()->builtins());
+  const int kNumFunctions = 4;
+  const char* function_syms[kNumFunctions] = {
+    "RegExpExec",
+    "StringMatch",
+    "StringReplace",
+    "StringSplit",
+  };
+  const char* function_noresult_syms[kNumFunctions] = {
+    "RegExpExecNoResult",
+    "StringMatchNoResult",
+    "StringReplaceNoResult",
+    "StringSplitNoResult",
+  };
+  Handle<JSFunction> functions[kNumFunctions];
+  Handle<JSFunction> noresult_functions[kNumFunctions];
+
+  for (int i = 0; i < kNumFunctions; ++i) {
+    Handle<String> sym = FACTORY->LookupAsciiSymbol(function_syms[i]);
+    { MaybeObject* maybe_function = builtins->GetProperty(*sym);
+      Object* obj;
+      if (!maybe_function->ToObject(&obj)) return;
+      if (!obj->IsJSFunction()) return;
+      functions[i] = Handle<JSFunction>(JSFunction::cast(obj));
+    }
+
+    Handle<String> noresult_sym =
+       FACTORY->LookupAsciiSymbol(function_noresult_syms[i]);
+    { MaybeObject* maybe_function = builtins->GetProperty(*noresult_sym);
+      Object* obj;
+      if (!maybe_function->ToObject(&obj)) return;
+      if (!obj->IsJSFunction()) return;
+      noresult_functions[i] = Handle<JSFunction>(JSFunction::cast(obj));
+    }
+  }
+
+  for (int i = 0; i < blocks_.length(); i++) {
+    for (HInstruction* instr = blocks_[i]->first();
+         instr != NULL;
+         instr = instr->next()) {
+      if (instr->IsCallConstantFunction() && instr->HasNoUses()) {
+        HCallConstantFunction* call = HCallConstantFunction::cast(instr);
+        Handle<JSFunction> function = call->function();
+        Handle<JSFunction> replace_function;
+        for (int i = 0; i < kNumFunctions; ++i) {
+          if (*function == *functions[i])
+            replace_function = noresult_functions[i];
+        }
+        if (!replace_function.is_null()) {
+          HCallConstantFunction* call_noresult =
+            new(zone()) HCallConstantFunction(replace_function,
+                                              call->argument_count());
+          call_noresult->InsertBefore(call);
+          call->Unlink();
+        }
+      }
+    }
+  }
+}
+
+
 bool HGraph::CheckArgumentsPhiUses() {
   int block_count = blocks_.length();
   for (int i = 0; i < block_count; ++i) {
     for (int j = 0; j < blocks_[i]->phis()->length(); ++j) {
       HPhi* phi = blocks_[i]->phis()->at(j);
       // We don't support phi uses of arguments for now.
       if (phi->CheckFlag(HValue::kIsArguments)) return false;
     }
   }
   return true;
@@ skipping 6429 matching lines @@
                                      expr->check_type())) {
         if (FLAG_trace_inlining) {
           PrintF("Inlining builtin ");
           expr->target()->ShortPrint();
           PrintF("\n");
         }
         return;
       }
 
       if (CallStubCompiler::HasCustomCallGenerator(expr->target()) ||
-          expr->check_type() != RECEIVER_MAP_CHECK) {
+          (expr->check_type() != RECEIVER_MAP_CHECK &&
+           expr->check_type() != STRING_CHECK)) {
         // When the target has a custom call IC generator, use the IC,
         // because it is likely to generate better code.  Also use the IC
         // when a primitive receiver check is required.
         HValue* context = environment()->LookupContext();
         call = PreProcessCall(
             new(zone()) HCallNamed(context, name, argument_count));
       } else {
         AddCheckConstantFunction(expr->holder(), receiver, receiver_map, true);
 
         if (TryInlineCall(expr)) return;
@@ skipping 2368 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal