Lookup getter/setter symbols before alllocating them, thus eliminating extra String allocations in …

runtime/vm/object.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 "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 2102 matching lines @@
       ASSERT(func.Owner() == raw());
       set.Insert(func);
     }
   }
   StorePointer(&raw_ptr()->functions_hash_table_, set.Release().raw());
 }
 
 
 void Class::AddFunction(const Function& function) const {
   const Array& arr = Array::Handle(functions());
-  const Array& new_arr = Array::Handle(Array::Grow(arr, arr.Length() + 1));
+  const Array& new_arr =
+      Array::Handle(Array::Grow(arr, arr.Length() + 1, Heap::kOld));
   new_arr.SetAt(arr.Length(), function);
   StorePointer(&raw_ptr()->functions_, new_arr.raw());
   // Add to hash table, if any.
   const intptr_t new_len = new_arr.Length();
   if (new_len == kFunctionLookupHashTreshold) {
     // Transition to using hash table.
     SetFunctions(new_arr);
   } else if (new_len > kFunctionLookupHashTreshold) {
     ClassFunctionsSet set(raw_ptr()->functions_hash_table_);
     set.Insert(function);
@@ skipping 5041 matching lines @@
   return "RedirectionData class";
 }
 
 
 void RedirectionData::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Object::PrintJSONImpl(stream, ref);
 }
 
 
 RawString* Field::GetterName(const String& field_name) {
-  return Field::GetterSymbol(field_name);
+  return String::Concat(Symbols::GetterPrefix(), field_name);
 }
 
 
 RawString* Field::GetterSymbol(const String& field_name) {
   return Symbols::FromConcat(Symbols::GetterPrefix(), field_name);
 }
 
 
+RawString* Field::LookupGetterSymbol(const String& field_name) {
+  return Symbols::LookupFromConcat(Symbols::GetterPrefix(), field_name);
+}
+
+
 RawString* Field::SetterName(const String& field_name) {
   return String::Concat(Symbols::SetterPrefix(), field_name);
 }
 
 
 RawString* Field::SetterSymbol(const String& field_name) {
   return Symbols::FromConcat(Symbols::SetterPrefix(), field_name);
 }
 
 
+RawString* Field::LookupSetterSymbol(const String& field_name) {
+  return Symbols::LookupFromConcat(Symbols::SetterPrefix(), field_name);
+}
+
+
 RawString* Field::NameFromGetter(const String& getter_name) {
   return Symbols::New(getter_name, kGetterPrefixLength,
       getter_name.Length() - kGetterPrefixLength);
 }
 
 
 RawString* Field::NameFromSetter(const String& setter_name) {
   return Symbols::New(setter_name, kSetterPrefixLength,
       setter_name.Length() - kSetterPrefixLength);
 }
@@ skipping 3488 matching lines @@
 RawObject* Namespace::Lookup(const String& name) const {
   Isolate* isolate = Isolate::Current();
   const Library& lib = Library::Handle(isolate, library());
   intptr_t ignore = 0;
 
   // Lookup the name in the library's symbols.
   Object& obj = Object::Handle(isolate, lib.LookupEntry(name, &ignore));
   if (!Field::IsGetterName(name) &&
       !Field::IsSetterName(name) &&
       (obj.IsNull() || obj.IsLibraryPrefix())) {
-    obj = lib.LookupEntry(String::Handle(Field::GetterName(name)), &ignore);
+    const String& getter_name = String::Handle(Field::LookupGetterSymbol(name));
+    if (!getter_name.IsNull()) {
+      obj = lib.LookupEntry(getter_name, &ignore);
+    }
     if (obj.IsNull()) {
-      obj = lib.LookupEntry(String::Handle(Field::SetterName(name)), &ignore);
+      const String& setter_name =
+          String::Handle(Field::LookupSetterSymbol(name));
+      if (!setter_name.IsNull()) {
+        obj = lib.LookupEntry(setter_name, &ignore);
+      }
     }
   }
 
   // Library prefixes are not exported.
   if (obj.IsNull() || obj.IsLibraryPrefix()) {
     // Lookup in the re-exported symbols.
     obj = lib.LookupReExport(name);
   }
   if (obj.IsNull() || HidesName(name) || obj.IsLibraryPrefix()) {
     return Object::null();
@@ skipping 6241 matching lines @@
   }
   return Integer::null();  // Notify caller that a bigint operation is required.
 }
 
 
 static bool Are64bitOperands(const Integer& op1, const Integer& op2) {
   return !op1.IsBigint() && !op2.IsBigint();
 }
 
 
-RawInteger* Integer::BitOp(Token::Kind kind, const Integer& other) const {
+RawInteger* Integer::BitOp(
+    Token::Kind kind, const Integer& other, Heap::Space space) const {
   if (IsSmi() && other.IsSmi()) {
     intptr_t op1_value = Smi::Value(Smi::RawCast(raw()));
     intptr_t op2_value = Smi::Value(Smi::RawCast(other.raw()));
     intptr_t result = 0;
     switch (kind) {
       case Token::kBIT_AND:
         result = op1_value & op2_value;
         break;
       case Token::kBIT_OR:
         result = op1_value | op2_value;
         break;
       case Token::kBIT_XOR:
         result = op1_value ^ op2_value;
         break;
       default:
         UNIMPLEMENTED();
     }
     ASSERT(Smi::IsValid(result));
     return Smi::New(result);
   } else if (Are64bitOperands(*this, other)) {
     int64_t a = AsInt64Value();
     int64_t b = other.AsInt64Value();
     switch (kind) {
       case Token::kBIT_AND:
-        return Integer::New(a & b);
+        return Integer::New(a & b, space);
       case Token::kBIT_OR:
-        return Integer::New(a | b);
+        return Integer::New(a | b, space);
       case Token::kBIT_XOR:
-        return Integer::New(a ^ b);
+        return Integer::New(a ^ b, space);
       default:
         UNIMPLEMENTED();
     }
   }
   return Integer::null();  // Notify caller that a bigint operation is required.
 }
 
 
 // TODO(srdjan): Clarify handling of negative right operand in a shift op.
 RawInteger* Smi::ShiftOp(Token::Kind kind,
                          const Smi& other,
+                         Heap::Space space,
                          const bool silent) const {
   intptr_t result = 0;
   const intptr_t left_value = Value();
   const intptr_t right_value = other.Value();
   ASSERT(right_value >= 0);
   switch (kind) {
     case Token::kSHL: {
       if ((left_value == 0) || (right_value == 0)) {
         return raw();
       }
       { // Check for overflow.
         int cnt = Utils::BitLength(left_value);
         if ((cnt + right_value) > Smi::kBits) {
           if ((cnt + right_value) > Mint::kBits) {
-            return Bigint::NewFromShiftedInt64(left_value, right_value);
+            return Bigint::NewFromShiftedInt64(left_value, right_value, space);
           } else {
             int64_t left_64 = left_value;
-            return Integer::New(left_64 << right_value, Heap::kNew, silent);
+            return Integer::New(left_64 << right_value, space, silent);
           }
         }
       }
       result = left_value << right_value;
       break;
     }
     case Token::kSHR: {
       const intptr_t shift_amount =
           (right_value >= kBitsPerWord) ? (kBitsPerWord - 1) : right_value;
       result = left_value >> shift_amount;
@@ skipping 4463 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart