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(SetUpKind set_up_kind) {
+  ASSERT(!initialized_ || set_up_kind == AFTER_DESERIALIZATION);
   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) {
-      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.
-      CodeDesc desc;
-      masm.GetCode(&desc);
-      Code::Flags flags =  functions[i].flags;
-      Object* code = NULL;
-      {
-        // During startup it's OK to always allocate and defer GC to later.
-        // This simplifies things because we don't need to retry.
-        AlwaysAllocateScope __scope__;
-        { MaybeObject* maybe_code =
-              heap->CreateCode(desc, flags, masm.CodeObject());
-          if (!maybe_code->ToObject(&code)) {
-            v8::internal::V8::FatalProcessOutOfMemory("CreateCode");
-          }
+    if (set_up_kind == AFTER_DESERIALIZATION && functions[i].in_snapshot) {
+      // This builtin was deserialized from the snapshot.
+      ASSERT(builtins_[i] != NULL);
+      continue;
+    }
+
+    if (set_up_kind == FOR_SNAPSHOT && !functions[i].in_snapshot) {
+      // This builtin should not be included in the snapshot.
+      builtins_[i] = NULL;
+      continue;
+    }
+
+    names_[i] = functions[i].s_name;
+
+    if (set_up_kind == BEFORE_DESERIALIZATION) {
+      builtins_[i] = NULL;
+      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.
+    CodeDesc desc;
+    masm.GetCode(&desc);
+    Code::Flags flags =  functions[i].flags;
+    Object* code = NULL;
+    {
+      // During startup it's OK to always allocate and defer GC to later.
+      // This simplifies things because we don't need to retry.
+      AlwaysAllocateScope __scope__;
+      { MaybeObject* maybe_code =
+            heap->CreateCode(desc, flags, masm.CodeObject());
+        if (!maybe_code->ToObject(&code)) {
+          v8::internal::V8::FatalProcessOutOfMemory("CreateCode");
         }
       }
-      // Log the event and add the code to the builtins array.
-      PROFILE(isolate,
-              CodeCreateEvent(Logger::BUILTIN_TAG,
-                              Code::cast(code),
-                              functions[i].s_name));
-      GDBJIT(AddCode(GDBJITInterface::BUILTIN,
-                     functions[i].s_name,
-                     Code::cast(code)));
-      builtins_[i] = code;
+    }
+    // Log the event and add the code to the builtins array.
+    PROFILE(isolate,
+            CodeCreateEvent(Logger::BUILTIN_TAG,
+                            Code::cast(code),
+                            functions[i].s_name));
+    GDBJIT(AddCode(GDBJITInterface::BUILTIN,
+                   functions[i].s_name,
+                   Code::cast(code)));
+    builtins_[i] = code;
 #ifdef ENABLE_DISASSEMBLER
-      if (FLAG_print_builtin_code) {
-        PrintF("Builtin: %s\n", functions[i].s_name);
-        Code::cast(code)->Disassemble(functions[i].s_name);
-        PrintF("\n");
-      }
+    if (FLAG_print_builtin_code) {
+      PrintF("Builtin: %s\n", functions[i].s_name);
+      Code::cast(code)->Disassemble(functions[i].s_name);
+      PrintF("\n");
+    }
 #endif
-    } else {
-      // Deserializing. The values will be filled in during IterateBuiltins.
-      builtins_[i] = NULL;
-    }
     names_[i] = functions[i].s_name;
   }
 
   // Mark as initialized.
   initialized_ = true;
 }
 
 
 void Builtins::TearDown() {
   initialized_ = false;
@@ skipping 18 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