Add fast paths for Smi values in the dart embedding api.

vm/dart_api_impl.cc

 // Copyright (c) 2012, 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 "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 1072 matching lines @@
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
   return obj.IsNumber();
 }
 
 
 // --- Integers ----
 
 
 DART_EXPORT bool Dart_IsInteger(Dart_Handle object) {
+  // Fast path for Smis.
+  if (Api::IsSmi(object)) {
+    return true;
+  }
+
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
   return obj.IsInteger();
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerFitsIntoInt64(Dart_Handle integer,
                                                   bool* fits) {
+  // Fast path for Smis.
   Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
+  CHECK_ISOLATE(isolate);
+  if (Api::IsSmi(integer)) {
+    *fits = true;
+    return Api::Success(isolate);
+  }
+
+  DARTSCOPE_NOCHECKS(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
   if (int_obj.IsSmi() || int_obj.IsMint()) {
     *fits = true;
   } else {
     ASSERT(int_obj.IsBigint());
 #if defined(DEBUG)
     Bigint& bigint = Bigint::Handle(isolate);
     bigint ^= int_obj.raw();
     ASSERT(!BigintOperations::FitsIntoMint(bigint));
 #endif
     *fits = false;
   }
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerFitsIntoUint64(Dart_Handle integer,
                                                    bool* fits) {
+  // Fast path for Smis.
   Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
+  CHECK_ISOLATE(isolate);
+  if (Api::IsSmi(integer)) {
+    *fits = (Api::SmiValue(integer) >= 0);
+    return Api::Success(isolate);
+  }
+
+  DARTSCOPE_NOCHECKS(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
   if (int_obj.IsSmi() || int_obj.IsMint()) {
     *fits = !int_obj.IsNegative();
   } else {
     ASSERT(int_obj.IsBigint());
     Bigint& bigint = Bigint::Handle(isolate);
     bigint ^= int_obj.raw();
     *fits = BigintOperations::FitsIntoUint64(bigint);
   }
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewInteger(int64_t value) {
+  // Fast path for Smis.
   Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
+  CHECK_ISOLATE(isolate);
+  if (Smi::IsValid64(value)) {
+    NOHANDLESCOPE(isolate);
+    return Api::NewHandle(isolate, Smi::New(value));
+  }
+
+  DARTSCOPE_NOCHECKS(isolate);
   return Api::NewHandle(isolate, Integer::New(value));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewIntegerFromHexCString(const char* str) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const String& str_obj = String::Handle(isolate, String::New(str));
   return Api::NewHandle(isolate, Integer::New(str_obj));
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerToInt64(Dart_Handle integer,
                                             int64_t* value) {
+  // Fast path for Smis.
   Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
+  CHECK_ISOLATE(isolate);
+  if (Api::IsSmi(integer)) {
+    *value = Api::SmiValue(integer);
+    return Api::Success(isolate);
+  }
+
+  DARTSCOPE_NOCHECKS(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
   if (int_obj.IsSmi() || int_obj.IsMint()) {
     *value = int_obj.AsInt64Value();
     return Api::Success(isolate);
   } else {
     ASSERT(int_obj.IsBigint());
     Bigint& bigint = Bigint::Handle(isolate);
     bigint ^= int_obj.raw();
     if (BigintOperations::FitsIntoMint(bigint)) {
       *value = BigintOperations::ToMint(bigint);
       return Api::Success(isolate);
     }
   }
   return Api::NewError("%s: Integer %s cannot be represented as an int64_t.",
                        CURRENT_FUNC, int_obj.ToCString());
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerToUint64(Dart_Handle integer,
                                              uint64_t* value) {
+  // Fast path for Smis.
   Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
+  CHECK_ISOLATE(isolate);
+  if (Api::IsSmi(integer)) {
+    intptr_t smi_value = Api::SmiValue(integer);
+    if (smi_value >= 0) {
+      *value = smi_value;
+      return Api::Success(isolate);
+    }
+  }
+
+  DARTSCOPE_NOCHECKS(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
   if (int_obj.IsSmi() || int_obj.IsMint()) {
     if (!int_obj.IsNegative()) {
       *value = int_obj.AsInt64Value();
       return Api::Success(isolate);
     }
   } else {
@@ skipping 2202 matching lines @@
       *buffer = NULL;
     }
     delete debug_region;
   } else {
     *buffer = NULL;
     *buffer_size = 0;
   }
 }
 
 }  // namespace dart