Store builtin index on the builtin code object.

src/serialize.cc

 // Copyright 2012 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/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
@@ skipping 1919 matching lines @@
                                        where_to_point, skip);
     return;
   }
 
   if (heap_object->IsCode()) {
     Code* code_object = Code::cast(heap_object);
     if (code_object->kind() == Code::BUILTIN) {
       SerializeBuiltin(code_object, how_to_code, where_to_point, skip);
       return;
     }
+    // TODO(yangguo) figure out whether other code kinds can be handled smarter.
   }
 
   if (heap_object == source_) {
     SerializeSourceObject(how_to_code, where_to_point, skip);
     return;
   }
 
   if (skip != 0) {
     sink_->Put(kSkip, "SkipFromSerializeObject");
     sink_->PutInt(skip, "SkipDistanceFromSerializeObject");
   }
   // Object has not yet been serialized.  Serialize it here.
   ObjectSerializer serializer(this, heap_object, sink_, how_to_code,
                               where_to_point);
   serializer.Serialize();
 }
 
 
 void CodeSerializer::SerializeBuiltin(Code* builtin, HowToCode how_to_code,
                                       WhereToPoint where_to_point, int skip) {
   if (skip != 0) {
     sink_->Put(kSkip, "SkipFromSerializeBuiltin");
     sink_->PutInt(skip, "SkipDistanceFromSerializeBuiltin");
   }
 
   ASSERT((how_to_code == kPlain && where_to_point == kStartOfObject) ||
          (how_to_code == kFromCode && where_to_point == kInnerPointer));
-  int id = 0;
-  do {  // Look for existing builtins in the list.
-    Code* b = isolate()->builtins()->builtin(static_cast<Builtins::Name>(id));
-    if (builtin == b) break;
-  } while (++id < Builtins::builtin_count);
-  ASSERT(id < Builtins::builtin_count);  // We must have found a one.
-
+  int builtin_index = builtin->builtin_index();
+  ASSERT_LT(builtin_index, Builtins::builtin_count);
+  ASSERT_LE(0, builtin_index);
   sink_->Put(kBuiltin + how_to_code + where_to_point, "Builtin");
-  sink_->PutInt(id, "builtin_index");
+  sink_->PutInt(builtin_index, "builtin_index");
 }
 
 
 void CodeSerializer::SerializeSourceObject(HowToCode how_to_code,
                                            WhereToPoint where_to_point,
                                            int skip) {
   if (skip != 0) {
     sink_->Put(kSkip, "SkipFromSerializeSourceObject");
     sink_->PutInt(skip, "SkipDistanceFromSerializeSourceObject");
   }
@@ skipping 44 matching lines @@
     SetHeaderValue(kReservationsOffset + i, cs->CurrentAllocationAddress(i));
   }
 }
 
 
 bool SerializedCodeData::IsSane() {
   return GetHeaderValue(kVersionHashOffset) == Version::Hash() &&
          PayloadLength() >= SharedFunctionInfo::kSize;
 }
 } }  // namespace v8::internal