[Isolates] Moved more compilation-related globals (builtins, runtime, &c.)...

src/codegen.cc

 // Copyright 2009 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 319 matching lines @@
       }
     }
   }
 
   // Invoke the platform-dependent code generator to do the actual
   // declaration the global variables and functions.
   DeclareGlobals(array);
 }
 
 
-// List of special runtime calls which are generated inline. For some of these
-// functions the code will be generated inline, and for others a call to a code
-// stub will be inlined.
-
-#define INLINE_RUNTIME_ENTRY(Name, argc, ressize)                             \
-    {&CodeGenerator::Generate##Name,  "_" #Name, argc},                       \
-
-CodeGenerator::InlineRuntimeLUT CodeGenerator::kInlineRuntimeLUT[] = {
-  INLINE_RUNTIME_FUNCTION_LIST(INLINE_RUNTIME_ENTRY)
-};
-
-#undef INLINE_RUNTIME_ENTRY
-
-CodeGenerator::InlineRuntimeLUT* CodeGenerator::FindInlineRuntimeLUT(
+InlineRuntimeFunctionsTable::Entry* CodeGenerator::FindInlineRuntimeLUT(
     Handle<String> name) {
-  const int entries_count =
-      sizeof(kInlineRuntimeLUT) / sizeof(InlineRuntimeLUT);
-  for (int i = 0; i < entries_count; i++) {
-    InlineRuntimeLUT* entry = &kInlineRuntimeLUT[i];
+  Isolate* isolate = Isolate::Current();
+  InlineRuntimeFunctionsTable::Entry* entries =
+      isolate->inline_runtime_functions_table()->entries();
+  for (int i = 0;
+       i < InlineRuntimeFunctionsTable::kInlineRuntimeFunctionsTableSize;
+       ++i) {
+    InlineRuntimeFunctionsTable::Entry* entry = &entries[i];
     if (name->IsEqualTo(CStrVector(entry->name))) {
       return entry;
     }
   }
   return NULL;
 }
 
 
 bool CodeGenerator::CheckForInlineRuntimeCall(CallRuntime* node) {
   ZoneList<Expression*>* args = node->arguments();
   Handle<String> name = node->name();
   if (name->length() > 0 && name->Get(0) == '_') {
-    InlineRuntimeLUT* entry = FindInlineRuntimeLUT(name);
+    InlineRuntimeFunctionsTable::Entry* entry = FindInlineRuntimeLUT(name);
     if (entry != NULL) {
       ((*this).*(entry->method))(args);
       return true;
     }
   }
   return false;
 }
 
 
 bool CodeGenerator::PatchInlineRuntimeEntry(Handle<String> name,
-    const CodeGenerator::InlineRuntimeLUT& new_entry,
-    CodeGenerator::InlineRuntimeLUT* old_entry) {
-  InlineRuntimeLUT* entry = FindInlineRuntimeLUT(name);
+    const InlineRuntimeFunctionsTable::Entry& new_entry,
+    InlineRuntimeFunctionsTable::Entry* old_entry) {
+  InlineRuntimeFunctionsTable::Entry* entry = FindInlineRuntimeLUT(name);
   if (entry == NULL) return false;
   if (old_entry != NULL) {
     old_entry->name = entry->name;
     old_entry->method = entry->method;
   }
   entry->name = new_entry.name;
   entry->method = new_entry.method;
   return true;
 }
 
 
 int CodeGenerator::InlineRuntimeCallArgumentsCount(Handle<String> name) {
-  CodeGenerator::InlineRuntimeLUT* f =
+  InlineRuntimeFunctionsTable::Entry* f =
       CodeGenerator::FindInlineRuntimeLUT(name);
   if (f != NULL) return f->nargs;
   return -1;
 }
 
 
 // Simple condition analysis.  ALWAYS_TRUE and ALWAYS_FALSE represent a
 // known result for the test expression, with no side effects.
 CodeGenerator::ConditionAnalysis CodeGenerator::AnalyzeCondition(
     Expression* cond) {
@@ skipping 100 matching lines @@
   }
 }
 
 
 void ApiGetterEntryStub::SetCustomCache(Code* value) {
   info()->set_load_stub_cache(value);
 }
 
 
 } }  // namespace v8::internal