ARM: Make use of d16-d31 when available.

src/builtins.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 1754 matching lines @@
 #undef DEF_JS_NAME
 #undef DEF_JS_ARGC
 
 struct BuiltinDesc {
   byte* generator;
   byte* c_code;
   const char* s_name;  // name is only used for generating log information.
   int name;
   Code::Flags flags;
   BuiltinExtraArguments extra_args;
+  bool in_snapshot;  // whether this builtin should be included in snapshot.
 };
 
 #define BUILTIN_FUNCTION_TABLE_INIT { V8_ONCE_INIT, {} }
 
 class BuiltinFunctionTable {
  public:
   BuiltinDesc* functions() {
     CallOnce(&once_, &Builtins::InitBuiltinFunctionTable);
     return functions_;
   }
@@ skipping 12 matching lines @@
 // within the lexical scope of Builtins:: and within a context where
 // Code::Flags names a non-abstract type.
 void Builtins::InitBuiltinFunctionTable() {
   BuiltinDesc* functions = builtin_function_table.functions_;
   functions[builtin_count].generator = NULL;
   functions[builtin_count].c_code = NULL;
   functions[builtin_count].s_name = NULL;
   functions[builtin_count].name = builtin_count;
   functions[builtin_count].flags = static_cast<Code::Flags>(0);
   functions[builtin_count].extra_args = NO_EXTRA_ARGUMENTS;
+  functions[builtin_count].in_snapshot = false;
 
 #define DEF_FUNCTION_PTR_C(aname, aextra_args)                         \
     functions->generator = FUNCTION_ADDR(Generate_Adaptor);            \
     functions->c_code = FUNCTION_ADDR(Builtin_##aname);                \
     functions->s_name = #aname;                                        \
     functions->name = c_##aname;                                       \
     functions->flags = Code::ComputeFlags(Code::BUILTIN);              \
     functions->extra_args = aextra_args;                               \
+    functions->in_snapshot = true;                                     \
     ++functions;
 
-#define DEF_FUNCTION_PTR_A(aname, kind, state, extra)                       \
+#define DEF_FUNCTION_PTR_A(aname, kind, state, extra, in_snapshot_arg)      \
     functions->generator = FUNCTION_ADDR(Generate_##aname);                 \
     functions->c_code = NULL;                                               \
     functions->s_name = #aname;                                             \
     functions->name = k##aname;                                             \
     functions->flags = Code::ComputeFlags(Code::kind,                       \
                                           state,                            \
                                           extra);                           \
     functions->extra_args = NO_EXTRA_ARGUMENTS;                             \
+    functions->in_snapshot = (in_snapshot_arg == IN_SNAPSHOT);              \
     ++functions;
 
   BUILTIN_LIST_C(DEF_FUNCTION_PTR_C)
   BUILTIN_LIST_A(DEF_FUNCTION_PTR_A)
   BUILTIN_LIST_DEBUG_A(DEF_FUNCTION_PTR_A)
 
 #undef DEF_FUNCTION_PTR_C
 #undef DEF_FUNCTION_PTR_A
 }
 
-void Builtins::SetUp(bool create_heap_objects) {
-  ASSERT(!initialized_);
+void Builtins::SetUp(bool create_heap_objects, bool after_serialization) {
+  ASSERT(!initialized_ || after_serialization);
   Isolate* isolate = Isolate::Current();
   Heap* heap = isolate->heap();
 
   // Create a scope for the handles in the builtins.
   HandleScope scope(isolate);
 
   const BuiltinDesc* functions = builtin_function_table.functions();
 
   // For now we generate builtin adaptor code into a stack-allocated
   // buffer, before copying it into individual code objects. Be careful
   // with alignment, some platforms don't like unaligned code.
   union { int force_alignment; byte buffer[8*KB]; } u;
 
   // Traverse the list of builtins and generate an adaptor in a
   // separate code object for each one.
   for (int i = 0; i < builtin_count; i++) {
-    if (create_heap_objects) {
+    if (after_serialization && functions[i].in_snapshot) {
+      // This builtin has already been generated.
+      continue;
+    }
+
+    if (create_heap_objects ||
+        (after_serialization && !functions[i].in_snapshot)) {
+      if (!after_serialization && !functions[i].in_snapshot) {
+        // This builtin should not be included in the snapshot.
+        continue;
+      }
+
       MacroAssembler masm(isolate, u.buffer, sizeof u.buffer);
       // Generate the code/adaptor.
       typedef void (*Generator)(MacroAssembler*, int, BuiltinExtraArguments);
       Generator g = FUNCTION_CAST<Generator>(functions[i].generator);
       // We pass all arguments to the generator, but it may not use all of
       // them.  This works because the first arguments are on top of the
       // stack.
       ASSERT(!masm.has_frame());
       g(&masm, functions[i].name, functions[i].extra_args);
       // Move the code into the object heap.
@@ skipping 63 matching lines @@
   return NULL;
 }
 
 
 #define DEFINE_BUILTIN_ACCESSOR_C(name, ignore)               \
 Handle<Code> Builtins::name() {                               \
   Code** code_address =                                       \
       reinterpret_cast<Code**>(builtin_address(k##name));     \
   return Handle<Code>(code_address);                          \
 }
-#define DEFINE_BUILTIN_ACCESSOR_A(name, kind, state, extra) \
-Handle<Code> Builtins::name() {                             \
-  Code** code_address =                                     \
-      reinterpret_cast<Code**>(builtin_address(k##name));   \
-  return Handle<Code>(code_address);                        \
+#define DEFINE_BUILTIN_ACCESSOR_A(name, kind, state, extra, extra2) \
+Handle<Code> Builtins::name() {                                     \
+  Code** code_address =                                             \
+      reinterpret_cast<Code**>(builtin_address(k##name));           \
+  return Handle<Code>(code_address);                                \
 }
 BUILTIN_LIST_C(DEFINE_BUILTIN_ACCESSOR_C)
 BUILTIN_LIST_A(DEFINE_BUILTIN_ACCESSOR_A)
 BUILTIN_LIST_DEBUG_A(DEFINE_BUILTIN_ACCESSOR_A)
 #undef DEFINE_BUILTIN_ACCESSOR_C
 #undef DEFINE_BUILTIN_ACCESSOR_A
 
 
 } }  // namespace v8::internal