Improve polymorphic inlining of int/int double/double operations.

runtime/vm/intermediate_language.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/intermediate_language.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/bit_vector.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/flow_graph_optimizer.h"
 #include "vm/flow_graph_range_analysis.h"
+#include "vm/intrinsifier.h"
 #include "vm/locations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/resolver.h"
 #include "vm/scopes.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 #include "vm/il_printer.h"
@@ skipping 444 matching lines @@
 CatchBlockEntryInstr* GraphEntryInstr::GetCatchEntry(intptr_t index) {
   // TODO(fschneider): Sort the catch entries by catch_try_index to avoid
   // searching.
   for (intptr_t i = 0; i < catch_entries_.length(); ++i) {
     if (catch_entries_[i]->catch_try_index() == index) return catch_entries_[i];
   }
   return NULL;
 }
 
 
-static bool StartsWith(const String& name, const char* prefix, intptr_t n) {
-  ASSERT(name.IsOneByteString());
-
-  if (name.Length() < n) {
-    return false;
-  }
-
-  for (intptr_t i = 0; i < n; i++) {
-    if (name.CharAt(i) != prefix[i]) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-
-static bool CompareNames(const Library& lib,
-                         const char* test_name,
-                         const String& name) {
-  ASSERT(Library::kPrivateIdentifierStart == '_');
-  const char* kPrivateGetterPrefix = "get:_";
-  const char* kPrivateSetterPrefix = "set:_";
-
-  if (test_name[0] == Library::kPrivateIdentifierStart) {
-    if (name.CharAt(0) != Library::kPrivateIdentifierStart) {
-      return false;
-    }
-  } else if (strncmp(test_name,
-                     kPrivateGetterPrefix,
-                     strlen(kPrivateGetterPrefix)) == 0) {
-    if (!StartsWith(name, kPrivateGetterPrefix, strlen(kPrivateGetterPrefix))) {
-      return false;
-    }
-  } else if (strncmp(test_name,
-                     kPrivateSetterPrefix,
-                     strlen(kPrivateSetterPrefix)) == 0) {
-    if (!StartsWith(name, kPrivateSetterPrefix, strlen(kPrivateSetterPrefix))) {
-      return false;
-    }
-  } else {
-    // Compare without mangling.
-    return name.Equals(test_name);
-  }
-
-  // Both names are private. Mangle test_name before comparison.
-  // Check if this is a constructor (e.g., List,), in which case the mangler
-  // needs some help (see comment in Library::PrivateName).
-  String& test_name_symbol = String::Handle();
-  if (test_name[strlen(test_name) - 1] == '.') {
-    test_name_symbol = Symbols::New(test_name, strlen(test_name) - 1);
-    test_name_symbol = lib.PrivateName(test_name_symbol);
-    test_name_symbol = String::Concat(test_name_symbol, Symbols::Dot());
-  } else {
-    test_name_symbol = Symbols::New(test_name);
-    test_name_symbol = lib.PrivateName(test_name_symbol);
-  }
-  return test_name_symbol.Equals(name);
-}
-
-
-static bool IsRecognizedLibrary(const Library& library) {
-  // List of libraries where methods can be recognized.
-  return (library.raw() == Library::CoreLibrary())
-      || (library.raw() == Library::MathLibrary())
-      || (library.raw() == Library::TypedDataLibrary())
-      || (library.raw() == Library::InternalLibrary());
-}
-
-
 MethodRecognizer::Kind MethodRecognizer::RecognizeKind(
     const Function& function) {
   if (!function.is_recognized()) {
     return kUnknown;
   }
 
   const Class& function_class = Class::Handle(function.Owner());
   const Library& lib = Library::Handle(function_class.library());
-  const String& function_name = String::Handle(function.name());
-  const String& class_name = String::Handle(function_class.Name());
+  const char* function_name = String::Handle(function.name()).ToCString();

[srdjan, 2014/08/18 18:04:49]

ToCString is expensive, should not be used in performance critical code. AFAIK,
MethodRecognizer appears in the profile of compilation. I fear this would have
negative impact on compilation speed.

What is the reason for these changes?

[Florian Schneider, 2014/08/18 18:22:57]

The reason was that I use the existing comparison code from the intrinsifier
which uses C strings only and can handle factory constructors. If it turns out
to be performance-critical I can change both (MethodRecognizer and Intrinsifier)
to avoid ToCString.

+  const char* class_name = String::Handle(function_class.Name()).ToCString();
 
 #define RECOGNIZE_FUNCTION(test_class_name, test_function_name, enum_name, fp) \
-  if (CompareNames(lib, #test_function_name, function_name) &&                 \
-      CompareNames(lib, #test_class_name, class_name)) {                       \
+  if (Intrinsifier::TestFunction(lib, class_name, function_name,               \
+                                 #test_class_name, #test_function_name)) {     \
     ASSERT(function.CheckSourceFingerprint(fp));                               \
     return k##enum_name;                                                       \
   }
 RECOGNIZED_LIST(RECOGNIZE_FUNCTION)
 #undef RECOGNIZE_FUNCTION
   UNREACHABLE();
   return kUnknown;
 }
 
 
+static bool IsRecognizedLibrary(const Library& library) {
+  // List of libraries where methods can be recognized.
+  return (library.raw() == Library::CoreLibrary())
+      || (library.raw() == Library::MathLibrary())
+      || (library.raw() == Library::TypedDataLibrary())
+      || (library.raw() == Library::InternalLibrary());
+}
+
+
 bool MethodRecognizer::AlwaysInline(const Function& function) {
   const Class& function_class = Class::Handle(function.Owner());
   const Library& lib = Library::Handle(function_class.library());
   if (!IsRecognizedLibrary(lib)) {
     return false;
   }
 
-  const String& function_name = String::Handle(function.name());
-  const String& class_name = String::Handle(function_class.Name());
+  const char* function_name = String::Handle(function.name()).ToCString();
+  const char* class_name = String::Handle(function_class.Name()).ToCString();
 
 #define RECOGNIZE_FUNCTION(test_class_name, test_function_name, enum_name, fp) \
-  if (CompareNames(lib, #test_function_name, function_name) &&                 \
-      CompareNames(lib, #test_class_name, class_name)) {                       \
+  if (Intrinsifier::TestFunction(lib, class_name, function_name,               \
+                                 #test_class_name, #test_function_name)) {     \
     ASSERT(function.CheckSourceFingerprint(fp));                               \
     return true;                                                               \
   }
 INLINE_WHITE_LIST(RECOGNIZE_FUNCTION)
 #undef RECOGNIZE_FUNCTION
   return false;
 }
 
 
 bool MethodRecognizer::PolymorphicTarget(const Function& function) {
   const Class& function_class = Class::Handle(function.Owner());
   const Library& lib = Library::Handle(function_class.library());
   if (!IsRecognizedLibrary(lib)) {
     return false;
   }
 
-  const String& function_name = String::Handle(function.name());
-  const String& class_name = String::Handle(function_class.Name());
+  const char* function_name = String::Handle(function.name()).ToCString();
+  const char* class_name = String::Handle(function_class.Name()).ToCString();
 
 #define RECOGNIZE_FUNCTION(test_class_name, test_function_name, enum_name, fp) \
-  if (CompareNames(lib, #test_function_name, function_name) &&                 \
-      CompareNames(lib, #test_class_name, class_name)) {                       \
+  if (Intrinsifier::TestFunction(lib, class_name, function_name,               \
+                                 #test_class_name, #test_function_name)) {     \
     ASSERT(function.CheckSourceFingerprint(fp));                               \
     return true;                                                               \
   }
 POLYMORPHIC_TARGET_LIST(RECOGNIZE_FUNCTION)
 #undef RECOGNIZE_FUNCTION
   return false;
 }
 
 
 const char* MethodRecognizer::KindToCString(Kind kind) {
@@ skipping 1846 matching lines @@
 void StaticCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const ICData* call_ic_data = NULL;
   if (!FLAG_propagate_ic_data || !compiler->is_optimizing()) {
     const Array& arguments_descriptor =
         Array::Handle(ArgumentsDescriptor::New(ArgumentCount(),
                                                argument_names()));
     // TODO(srdjan): Improve performance of function recognition.
     MethodRecognizer::Kind recognized_kind =
         MethodRecognizer::RecognizeKind(function());
     int num_args_checked = 0;
-    if ((recognized_kind == MethodRecognizer::kMathMin) ||
-        (recognized_kind == MethodRecognizer::kMathMax)) {
-      num_args_checked = 2;
+    switch (recognized_kind) {
+      case MethodRecognizer::kDoubleFromInteger:
+        num_args_checked = 1;
+        break;
+      case MethodRecognizer::kMathMin:
+      case MethodRecognizer::kMathMax:
+        num_args_checked = 2;
+        break;
+      default:
+        break;
     }
     call_ic_data = compiler->GetOrAddStaticCallICData(deopt_id(),
                                                       function(),
                                                       arguments_descriptor,
                                                       num_args_checked);
   } else {
     call_ic_data = &ICData::ZoneHandle(ic_data()->raw());
   }
   if (!compiler->is_optimizing()) {
     // Some static calls can be optimized by the optimizing compiler (e.g. sqrt)
@@ skipping 474 matching lines @@
     case Token::kTRUNCDIV: return 0;
     case Token::kMOD: return 1;
     default: UNIMPLEMENTED(); return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart