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

src/runtime.cc

 // Copyright 2006-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 34 matching lines @@
 #include "runtime.h"
 #include "scopeinfo.h"
 #include "smart-pointer.h"
 #include "stub-cache.h"
 #include "v8threads.h"
 
 namespace v8 {
 namespace internal {
 
 
+RuntimeState::RuntimeState()
+    : algorithm_(SIMPLE_SEARCH) {
+  memset(bad_char_occurrence_, 0,
+         sizeof(bad_char_occurrence_[0]) * kBMAlphabetSize);
+}
+
+
 #define RUNTIME_ASSERT(value) \
   if (!(value)) return Isolate::Current()->ThrowIllegalOperation();
 
 // Cast the given object to a value of the specified type and store
 // it in a variable with the given name.  If the object is not of the
 // expected type call IllegalOperation and return.
 #define CONVERT_CHECKED(Type, name, obj)                             \
   RUNTIME_ASSERT(obj->Is##Type());                                   \
   Type* name = Type::cast(obj);
 
@@ skipping 22 matching lines @@
   RUNTIME_ASSERT(obj->IsNumber());                                   \
   double name = (obj)->Number();
 
 // Call the specified converter on the object *comand store the result in
 // a variable of the specified type with the given name.  If the
 // object is not a Number call IllegalOperation and return.
 #define CONVERT_NUMBER_CHECKED(type, name, Type, obj)                \
   RUNTIME_ASSERT(obj->IsNumber());                                   \
   type name = NumberTo##Type(obj);
 
-// Non-reentrant string buffer for efficient general use in this file.
-static StaticResource<StringInputBuffer> runtime_string_input_buffer;
-
 
 static Object* DeepCopyBoilerplate(Heap* heap, JSObject* boilerplate) {
   StackLimitCheck check;
   if (check.HasOverflowed()) return Isolate::Current()->StackOverflow();
 
   Object* result = heap->CopyJSObject(boilerplate);
   if (result->IsFailure()) return result;
   JSObject* copy = JSObject::cast(result);
 
   // Deep copy local properties.
@@ skipping 1273 matching lines @@
   // on Array.prototype and below.
   prototype->set_elements(HEAP->empty_fixed_array());
   return Smi::FromInt(0);
 }
 
 
 static Handle<JSFunction> InstallBuiltin(Handle<JSObject> holder,
                                          const char* name,
                                          Builtins::Name builtin_name) {
   Handle<String> key = Factory::LookupAsciiSymbol(name);
-  Handle<Code> code(Builtins::builtin(builtin_name));
+  Handle<Code> code(Isolate::Current()->builtins()->builtin(builtin_name));
   Handle<JSFunction> optimized = Factory::NewFunction(key,
                                                       JS_OBJECT_TYPE,
                                                       JSObject::kHeaderSize,
                                                       code,
                                                       false);
   optimized->shared()->DontAdaptArguments();
   SetProperty(holder, key, optimized, NONE);
   return optimized;
 }
 
@@ skipping 906 matching lines @@
 
   ASSERT(last_match_info->HasFastElements());
 
   return StringReplaceRegExpWithString(subject,
                                        regexp,
                                        replacement,
                                        last_match_info);
 }
 
 
-// Cap on the maximal shift in the Boyer-Moore implementation. By setting a
-// limit, we can fix the size of tables.
-static const int kBMMaxShift = 0xff;
-// Reduce alphabet to this size.
-static const int kBMAlphabetSize = 0x100;
-// For patterns below this length, the skip length of Boyer-Moore is too short
-// to compensate for the algorithmic overhead compared to simple brute force.
-static const int kBMMinPatternLength = 5;
-
-// Holds the two buffers used by Boyer-Moore string search's Good Suffix
-// shift. Only allows the last kBMMaxShift characters of the needle
-// to be indexed.
-class BMGoodSuffixBuffers {
- public:
-  BMGoodSuffixBuffers() {}
-  inline void init(int needle_length) {
-    ASSERT(needle_length > 1);
-    int start = needle_length < kBMMaxShift ? 0 : needle_length - kBMMaxShift;
-    int len = needle_length - start;
-    biased_suffixes_ = suffixes_ - start;
-    biased_good_suffix_shift_ = good_suffix_shift_ - start;
-    for (int i = 0; i <= len; i++) {
-      good_suffix_shift_[i] = len;
-    }
-  }
-  inline int& suffix(int index) {
-    ASSERT(biased_suffixes_ + index >= suffixes_);
-    return biased_suffixes_[index];
-  }
-  inline int& shift(int index) {
-    ASSERT(biased_good_suffix_shift_ + index >= good_suffix_shift_);
-    return biased_good_suffix_shift_[index];
-  }
- private:
-  int suffixes_[kBMMaxShift + 1];
-  int good_suffix_shift_[kBMMaxShift + 1];
-  int* biased_suffixes_;
-  int* biased_good_suffix_shift_;
-  DISALLOW_COPY_AND_ASSIGN(BMGoodSuffixBuffers);
-};
-
-// buffers reused by BoyerMoore
-static int bad_char_occurrence[kBMAlphabetSize];
-static BMGoodSuffixBuffers bmgs_buffers;
-
-// State of the string match tables.
-// SIMPLE: No usable content in the buffers.
-// BOYER_MOORE_HORSPOOL: The bad_char_occurences table has been populated.
-// BOYER_MOORE: The bmgs_buffers tables have also been populated.
-// Whenever starting with a new needle, one should call InitializeStringSearch
-// to determine which search strategy to use, and in the case of a long-needle
-// strategy, the call also initializes the algorithm to SIMPLE.
-enum StringSearchAlgorithm { SIMPLE_SEARCH, BOYER_MOORE_HORSPOOL, BOYER_MOORE };
-static StringSearchAlgorithm algorithm;
-
-
 // Compute the bad-char table for Boyer-Moore in the static buffer.
 template <typename pchar>
-static void BoyerMoorePopulateBadCharTable(Vector<const pchar> pattern) {
+static void BoyerMoorePopulateBadCharTable(RuntimeState* state,
+                                           Vector<const pchar> pattern) {
+  int* bad_char_occurrence = state->bad_char_occurrence();
   // Only preprocess at most kBMMaxShift last characters of pattern.
-  int start = pattern.length() < kBMMaxShift ? 0
-                                             : pattern.length() - kBMMaxShift;
+  int start = pattern.length() < RuntimeState::kBMMaxShift ? 0
+      : pattern.length() - RuntimeState::kBMMaxShift;
   // Run forwards to populate bad_char_table, so that *last* instance
   // of character equivalence class is the one registered.
   // Notice: Doesn't include the last character.
   int table_size = (sizeof(pchar) == 1) ? String::kMaxAsciiCharCode + 1
-                                        : kBMAlphabetSize;
+                                        : RuntimeState::kBMAlphabetSize;
   if (start == 0) {  // All patterns less than kBMMaxShift in length.
     memset(bad_char_occurrence, -1, table_size * sizeof(*bad_char_occurrence));
   } else {
     for (int i = 0; i < table_size; i++) {
       bad_char_occurrence[i] = start - 1;
     }
   }
   for (int i = start; i < pattern.length() - 1; i++) {
     pchar c = pattern[i];
-    int bucket = (sizeof(pchar) ==1) ? c : c % kBMAlphabetSize;
+    int bucket = (sizeof(pchar) ==1) ? c : c % RuntimeState::kBMAlphabetSize;
     bad_char_occurrence[bucket] = i;
   }
 }
 
 
 template <typename pchar>
-static void BoyerMoorePopulateGoodSuffixTable(Vector<const pchar> pattern) {
+static void BoyerMoorePopulateGoodSuffixTable(RuntimeState* state,
+                                              Vector<const pchar> pattern) {
+  RuntimeState::BMGoodSuffixBuffers& bmgs_buffers = *state->bmgs_buffers();
   int m = pattern.length();
-  int start = m < kBMMaxShift ? 0 : m - kBMMaxShift;
+  int start = m < RuntimeState::kBMMaxShift ? 0 : m - RuntimeState::kBMMaxShift;
   int len = m - start;
   // Compute Good Suffix tables.
   bmgs_buffers.init(m);
 
   bmgs_buffers.shift(m-1) = 1;
   bmgs_buffers.suffix(m) = m + 1;
   pchar last_char = pattern[m - 1];
   int suffix = m + 1;
   for (int i = m; i > start;) {
     for (pchar c = pattern[i - 1]; suffix <= m && c != pattern[suffix - 1];) {
@@ skipping 28 matching lines @@
       }
       if (i == suffix) {
         suffix = bmgs_buffers.suffix(suffix);
       }
     }
   }
 }
 
 
 template <typename schar, typename pchar>
-static inline int CharOccurrence(int char_code) {
+static inline int CharOccurrence(RuntimeState* state, int char_code) {
+  int* bad_char_occurrence = state->bad_char_occurrence();
   if (sizeof(schar) == 1) {
     return bad_char_occurrence[char_code];
   }
   if (sizeof(pchar) == 1) {
     if (char_code > String::kMaxAsciiCharCode) {
       return -1;
     }
     return bad_char_occurrence[char_code];
   }
-  return bad_char_occurrence[char_code % kBMAlphabetSize];
+  return bad_char_occurrence[char_code % RuntimeState::kBMAlphabetSize];
 }
 
 
 // Restricted simplified Boyer-Moore string matching.
 // Uses only the bad-shift table of Boyer-Moore and only uses it
 // for the character compared to the last character of the needle.
 template <typename schar, typename pchar>
-static int BoyerMooreHorspool(Vector<const schar> subject,
+static int BoyerMooreHorspool(RuntimeState* state,
+                              Vector<const schar> subject,
                               Vector<const pchar> pattern,
                               int start_index,
                               bool* complete) {
-  ASSERT(algorithm <= BOYER_MOORE_HORSPOOL);
+  ASSERT(state->algorithm() <= RuntimeState::BOYER_MOORE_HORSPOOL);
   int n = subject.length();
   int m = pattern.length();
 
   int badness = -m;
 
   // How bad we are doing without a good-suffix table.
   int idx;  // No matches found prior to this index.
   pchar last_char = pattern[m - 1];
-  int last_char_shift = m - 1 - CharOccurrence<schar, pchar>(last_char);
+  int last_char_shift = m - 1 - CharOccurrence<schar, pchar>(state, last_char);
   // Perform search
   for (idx = start_index; idx <= n - m;) {
     int j = m - 1;
     int c;
     while (last_char != (c = subject[idx + j])) {
-      int bc_occ = CharOccurrence<schar, pchar>(c);
+      int bc_occ = CharOccurrence<schar, pchar>(state, c);
       int shift = j - bc_occ;
       idx += shift;
       badness += 1 - shift;  // at most zero, so badness cannot increase.
       if (idx > n - m) {
         *complete = true;
         return -1;
       }
     }
     j--;
     while (j >= 0 && pattern[j] == (subject[idx + j])) j--;
@@ skipping 12 matching lines @@
         return idx;
       }
     }
   }
   *complete = true;
   return -1;
 }
 
 
 template <typename schar, typename pchar>
-static int BoyerMooreIndexOf(Vector<const schar> subject,
+static int BoyerMooreIndexOf(RuntimeState* state,
+                             Vector<const schar> subject,
                              Vector<const pchar> pattern,
                              int idx) {
-  ASSERT(algorithm <= BOYER_MOORE);
+  ASSERT(state->algorithm() <= RuntimeState::BOYER_MOORE);
+  RuntimeState::BMGoodSuffixBuffers& bmgs_buffers = *state->bmgs_buffers();
   int n = subject.length();
   int m = pattern.length();
   // Only preprocess at most kBMMaxShift last characters of pattern.
-  int start = m < kBMMaxShift ? 0 : m - kBMMaxShift;
+  int start = m < RuntimeState::kBMMaxShift ? 0 : m - RuntimeState::kBMMaxShift;
 
   pchar last_char = pattern[m - 1];
   // Continue search from i.
   while (idx <= n - m) {
     int j = m - 1;
     schar c;
     while (last_char != (c = subject[idx + j])) {
-      int shift = j - CharOccurrence<schar, pchar>(c);
+      int shift = j - CharOccurrence<schar, pchar>(state, c);
       idx += shift;
       if (idx > n - m) {
         return -1;
       }
     }
     while (j >= 0 && pattern[j] == (c = subject[idx + j])) j--;
     if (j < 0) {
       return idx;
     } else if (j < start) {
       // we have matched more than our tables allow us to be smart about.
       // Fall back on BMH shift.
-      idx += m - 1 - CharOccurrence<schar, pchar>(last_char);
+      idx += m - 1 - CharOccurrence<schar, pchar>(state, last_char);
     } else {
       int gs_shift = bmgs_buffers.shift(j + 1);       // Good suffix shift.
-      int bc_occ = CharOccurrence<schar, pchar>(c);
+      int bc_occ = CharOccurrence<schar, pchar>(state, c);
       int shift = j - bc_occ;                         // Bad-char shift.
       if (gs_shift > shift) {
         shift = gs_shift;
       }
       idx += shift;
     }
   }
 
   return -1;
 }
@@ skipping 119 matching lines @@
   return -1;
 }
 
 
 // Strategy for searching for a string in another string.
 enum StringSearchStrategy { SEARCH_FAIL, SEARCH_SHORT, SEARCH_LONG };
 
 
 template <typename pchar>
 static inline StringSearchStrategy InitializeStringSearch(
-    Vector<const pchar> pat, bool ascii_subject) {
+    RuntimeState* state, Vector<const pchar> pat, bool ascii_subject) {
   ASSERT(pat.length() > 1);
   // We have an ASCII haystack and a non-ASCII needle. Check if there
   // really is a non-ASCII character in the needle and bail out if there
   // is.
   if (ascii_subject && sizeof(pchar) > 1) {
     for (int i = 0; i < pat.length(); i++) {
       uc16 c = pat[i];
       if (c > String::kMaxAsciiCharCode) {
         return SEARCH_FAIL;
       }
     }
   }
-  if (pat.length() < kBMMinPatternLength) {
+  if (pat.length() < RuntimeState::kBMMinPatternLength) {
     return SEARCH_SHORT;
   }
-  algorithm = SIMPLE_SEARCH;
+  state->set_algorithm(RuntimeState::SIMPLE_SEARCH);
   return SEARCH_LONG;
 }
 
 
 // Dispatch long needle searches to different algorithms.
 template <typename schar, typename pchar>
-static int ComplexIndexOf(Vector<const schar> sub,
+static int ComplexIndexOf(RuntimeState* state,
+                          Vector<const schar> sub,
                           Vector<const pchar> pat,
                           int start_index) {
-  ASSERT(pat.length() >= kBMMinPatternLength);
+  ASSERT(pat.length() >= RuntimeState::kBMMinPatternLength);
   // Try algorithms in order of increasing setup cost and expected performance.
   bool complete;
   int idx = start_index;
-  switch (algorithm) {
-    case SIMPLE_SEARCH:
+  switch (state->algorithm()) {
+    case RuntimeState::SIMPLE_SEARCH:
       idx = SimpleIndexOf(sub, pat, idx, &complete);
       if (complete) return idx;
-      BoyerMoorePopulateBadCharTable(pat);
-      algorithm = BOYER_MOORE_HORSPOOL;
+      BoyerMoorePopulateBadCharTable(state, pat);
+      state->set_algorithm(RuntimeState::BOYER_MOORE_HORSPOOL);
       // FALLTHROUGH.
-    case BOYER_MOORE_HORSPOOL:
-      idx = BoyerMooreHorspool(sub, pat, idx, &complete);
+    case RuntimeState::BOYER_MOORE_HORSPOOL:
+      idx = BoyerMooreHorspool(state, sub, pat, idx, &complete);
       if (complete) return idx;
       // Build the Good Suffix table and continue searching.
-      BoyerMoorePopulateGoodSuffixTable(pat);
-      algorithm = BOYER_MOORE;
+      BoyerMoorePopulateGoodSuffixTable(state, pat);
+      state->set_algorithm(RuntimeState::BOYER_MOORE);
       // FALLTHROUGH.
-    case BOYER_MOORE:
-      return BoyerMooreIndexOf(sub, pat, idx);
+    case RuntimeState::BOYER_MOORE:
+      return BoyerMooreIndexOf(state, sub, pat, idx);
   }
   UNREACHABLE();
   return -1;
 }
 
 
 // Dispatch to different search strategies for a single search.
 // If searching multiple times on the same needle, the search
 // strategy should only be computed once and then dispatch to different
 // loops.
 template <typename schar, typename pchar>
-static int StringSearch(Vector<const schar> sub,
+static int StringSearch(RuntimeState* state,
+                        Vector<const schar> sub,
                         Vector<const pchar> pat,
                         int start_index) {
   bool ascii_subject = (sizeof(schar) == 1);
-  StringSearchStrategy strategy = InitializeStringSearch(pat, ascii_subject);
+  StringSearchStrategy strategy = InitializeStringSearch(state, pat,
+                                                         ascii_subject);
   switch (strategy) {
     case SEARCH_FAIL: return -1;
     case SEARCH_SHORT: return SimpleIndexOf(sub, pat, start_index);
-    case SEARCH_LONG: return ComplexIndexOf(sub, pat, start_index);
+    case SEARCH_LONG: return ComplexIndexOf(state, sub, pat, start_index);
   }
   UNREACHABLE();
   return -1;
 }
 
 
 // Perform string match of pattern on subject, starting at start index.
 // Caller must ensure that 0 <= start_index <= sub->length(),
 // and should check that pat->length() + start_index <= sub->length()
 int Runtime::StringMatch(Handle<String> sub,
                          Handle<String> pat,
                          int start_index) {
   ASSERT(0 <= start_index);
   ASSERT(start_index <= sub->length());
+  Isolate* isolate = Isolate::Current();
 
   int pattern_length = pat->length();
   if (pattern_length == 0) return start_index;
 
   int subject_length = sub->length();
   if (start_index + pattern_length > subject_length) return -1;
 
   if (!sub->IsFlat()) {
     FlattenString(sub);
   }
@@ skipping 24 matching lines @@
 
   if (!pat->IsFlat()) {
     FlattenString(pat);
   }
 
   AssertNoAllocation no_heap_allocation;  // ensure vectors stay valid
   // dispatch on type of strings
   if (pat->IsAsciiRepresentation()) {
     Vector<const char> pat_vector = pat->ToAsciiVector();
     if (sub->IsAsciiRepresentation()) {
-      return StringSearch(sub->ToAsciiVector(), pat_vector, start_index);
+      return StringSearch(isolate->runtime_state(), sub->ToAsciiVector(),
+                          pat_vector, start_index);
     }
-    return StringSearch(sub->ToUC16Vector(), pat_vector, start_index);
+    return StringSearch(isolate->runtime_state(), sub->ToUC16Vector(),
+                        pat_vector, start_index);
   }
   Vector<const uc16> pat_vector = pat->ToUC16Vector();
   if (sub->IsAsciiRepresentation()) {
-    return StringSearch(sub->ToAsciiVector(), pat_vector, start_index);
+    return StringSearch(isolate->runtime_state(), sub->ToAsciiVector(),
+                        pat_vector, start_index);
   }
-  return StringSearch(sub->ToUC16Vector(), pat_vector, start_index);
+  return StringSearch(isolate->runtime_state(), sub->ToUC16Vector(), pat_vector,
+                      start_index);
 }
 
 
 static Object* Runtime_StringIndexOf(Arguments args) {
   HandleScope scope;  // create a new handle scope
   ASSERT(args.length() == 3);
 
   CONVERT_ARG_CHECKED(String, sub, 0);
   CONVERT_ARG_CHECKED(String, pat, 1);
 
@@ skipping 142 matching lines @@
 
   // No need to flatten if we are going to find the answer on the first
   // character.  At this point we know there is at least one character
   // in each string, due to the trivial case handling above.
   int d = str1->Get(0) - str2->Get(0);
   if (d != 0) return Smi::FromInt(d);
 
   str1->TryFlatten();
   str2->TryFlatten();
 
-  static StringInputBuffer buf1;
-  static StringInputBuffer buf2;
+  Isolate* isolate = Isolate::Current();
+  StringInputBuffer& buf1 =
+      *isolate->runtime_state()->string_locale_compare_buf1();
+  StringInputBuffer& buf2 =
+      *isolate->runtime_state()->string_locale_compare_buf2();
 
   buf1.Reset(str1);
   buf2.Reset(str2);
 
   for (int i = 0; i < end; i++) {
     uint16_t char1 = buf1.GetNext();
     uint16_t char2 = buf2.GetNext();
     if (char1 != char2) return Smi::FromInt(char1 - char2);
   }
 
@@ skipping 175 matching lines @@
                                last_match_info,
                                match_pos,
                                match_pos + 1);
     return true;
   }
   return false;  // No matches at all.
 }
 
 
 template <typename schar, typename pchar>
-static bool SearchStringMultiple(Vector<schar> subject,
+static bool SearchStringMultiple(RuntimeState* state,
+                                 Vector<schar> subject,
                                  String* pattern,
                                  Vector<pchar> pattern_string,
                                  FixedArrayBuilder* builder,
                                  int* match_pos) {
   int pos = *match_pos;
   int subject_length = subject.length();
   int pattern_length = pattern_string.length();
   int max_search_start = subject_length - pattern_length;
   bool is_ascii = (sizeof(schar) == 1);
   StringSearchStrategy strategy =
-      InitializeStringSearch(pattern_string, is_ascii);
+      InitializeStringSearch(state, pattern_string, is_ascii);
   switch (strategy) {
     case SEARCH_FAIL: break;
     case SEARCH_SHORT:
       while (pos <= max_search_start) {
         if (!builder->HasCapacity(kMaxBuilderEntriesPerRegExpMatch)) {
           *match_pos = pos;
           return false;
         }
         // Position of end of previous match.
         int match_end = pos + pattern_length;
@@ skipping 12 matching lines @@
         }
       }
       break;
     case SEARCH_LONG:
       while (pos  <= max_search_start) {
         if (!builder->HasCapacity(kMaxBuilderEntriesPerRegExpMatch)) {
           *match_pos = pos;
           return false;
         }
         int match_end = pos + pattern_length;
-        int new_pos = ComplexIndexOf(subject, pattern_string, match_end);
+        int new_pos = ComplexIndexOf(state, subject, pattern_string, match_end);
         if (new_pos >= 0) {
           // A match has been found.
           if (new_pos > match_end) {
             ReplacementStringBuilder::AddSubjectSlice(builder,
                                                       match_end,
                                                       new_pos);
           }
           pos = new_pos;
           builder->Add(pattern);
         } else {
          break;
         }
       }
       break;
   }
   if (pos < max_search_start) {
     ReplacementStringBuilder::AddSubjectSlice(builder,
                                               pos + pattern_length,
                                               subject_length);
   }
   *match_pos = pos;
   return true;
 }
 
 
-static bool SearchStringMultiple(Handle<String> subject,
+static bool SearchStringMultiple(RuntimeState* state,
+                                 Handle<String> subject,
                                  Handle<String> pattern,
                                  Handle<JSArray> last_match_info,
                                  FixedArrayBuilder* builder) {
   ASSERT(subject->IsFlat());
   ASSERT(pattern->IsFlat());
   ASSERT(pattern->length() > 1);
 
   // Treating as if a previous match was before first character.
   int match_pos = -pattern->length();
 
   for (;;) {  // Break when search complete.
     builder->EnsureCapacity(kMaxBuilderEntriesPerRegExpMatch);
     AssertNoAllocation no_gc;
     if (subject->IsAsciiRepresentation()) {
       Vector<const char> subject_vector = subject->ToAsciiVector();
       if (pattern->IsAsciiRepresentation()) {
-        if (SearchStringMultiple(subject_vector,
+        if (SearchStringMultiple(state,
+                                 subject_vector,
                                  *pattern,
                                  pattern->ToAsciiVector(),
                                  builder,
                                  &match_pos)) break;
       } else {
-        if (SearchStringMultiple(subject_vector,
+        if (SearchStringMultiple(state,
+                                 subject_vector,
                                  *pattern,
                                  pattern->ToUC16Vector(),
                                  builder,
                                  &match_pos)) break;
       }
     } else {
       Vector<const uc16> subject_vector = subject->ToUC16Vector();
       if (pattern->IsAsciiRepresentation()) {
-        if (SearchStringMultiple(subject_vector,
+        if (SearchStringMultiple(state,
+                                 subject_vector,
                                  *pattern,
                                  pattern->ToAsciiVector(),
                                  builder,
                                  &match_pos)) break;
       } else {
-        if (SearchStringMultiple(subject_vector,
+        if (SearchStringMultiple(state,
+                                 subject_vector,
                                  *pattern,
                                  pattern->ToUC16Vector(),
                                  builder,
                                  &match_pos)) break;
       }
     }
   }
 
   if (match_pos >= 0) {
     SetLastMatchInfoNoCaptures(subject,
@@ skipping 183 matching lines @@
       return RegExpImpl::RE_SUCCESS;
     }
   }
   // No matches at all, return failure or exception result directly.
   return result;
 }
 
 
 static Object* Runtime_RegExpExecMultiple(Arguments args) {
   ASSERT(args.length() == 4);
+  Isolate* isolate = Isolate::Current();
   HandleScope handles;
 
   CONVERT_ARG_CHECKED(String, subject, 1);
   if (!subject->IsFlat()) { FlattenString(subject); }
   CONVERT_ARG_CHECKED(JSRegExp, regexp, 0);
   CONVERT_ARG_CHECKED(JSArray, last_match_info, 2);
   CONVERT_ARG_CHECKED(JSArray, result_array, 3);
 
   ASSERT(last_match_info->HasFastElements());
   ASSERT(regexp->GetFlags().is_global());
@@ skipping 11 matching lines @@
         String::cast(regexp->DataAt(JSRegExp::kAtomPatternIndex)));
     int pattern_length = pattern->length();
     if (pattern_length == 1) {
       if (SearchCharMultiple(subject, pattern, last_match_info, &builder)) {
         return *builder.ToJSArray(result_array);
       }
       return HEAP->null_value();
     }
 
     if (!pattern->IsFlat()) FlattenString(pattern);
-    if (SearchStringMultiple(subject, pattern, last_match_info, &builder)) {
+    if (SearchStringMultiple(isolate->runtime_state(), subject, pattern,
+                             last_match_info, &builder)) {
       return *builder.ToJSArray(result_array);
     }
     return HEAP->null_value();
   }
 
   ASSERT_EQ(regexp->TypeTag(), JSRegExp::IRREGEXP);
 
   RegExpImpl::IrregexpResult result;
   if (regexp->CaptureCount() == 0) {
     result = SearchRegExpNoCaptureMultiple(subject,
@@ skipping 1127 matching lines @@
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   };
   return kNotEscaped[character] != 0;
 }
 
 
 static Object* Runtime_URIEscape(Arguments args) {
   const char hex_chars[] = "0123456789ABCDEF";
+  Isolate* isolate = Isolate::Current();
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
   CONVERT_CHECKED(String, source, args[0]);
 
   source->TryFlatten();
 
   int escaped_length = 0;
   int length = source->length();
   {
-    Access<StringInputBuffer> buffer(&runtime_string_input_buffer);
+    Access<StringInputBuffer> buffer(
+        isolate->runtime_state()->string_input_buffer());
     buffer->Reset(source);
     while (buffer->has_more()) {
       uint16_t character = buffer->GetNext();
       if (character >= 256) {
         escaped_length += 6;
       } else if (IsNotEscaped(character)) {
         escaped_length++;
       } else {
         escaped_length += 3;
       }
       // We don't allow strings that are longer than a maximal length.
       ASSERT(String::kMaxLength < 0x7fffffff - 6);  // Cannot overflow.
       if (escaped_length > String::kMaxLength) {
         Isolate::Current()->context()->mark_out_of_memory();
         return Failure::OutOfMemoryException();
       }
     }
   }
   // No length change implies no change.  Return original string if no change.
   if (escaped_length == length) {
     return source;
   }
   Object* o = HEAP->AllocateRawAsciiString(escaped_length);
   if (o->IsFailure()) return o;
   String* destination = String::cast(o);
   int dest_position = 0;
 
-  Access<StringInputBuffer> buffer(&runtime_string_input_buffer);
+  Access<StringInputBuffer> buffer(
+      isolate->runtime_state()->string_input_buffer());
   buffer->Rewind();
   while (buffer->has_more()) {
     uint16_t chr = buffer->GetNext();
     if (chr >= 256) {
       destination->Set(dest_position, '%');
       destination->Set(dest_position+1, 'u');
       destination->Set(dest_position+2, hex_chars[chr >> 12]);
       destination->Set(dest_position+3, hex_chars[(chr >> 8) & 0xf]);
       destination->Set(dest_position+4, hex_chars[(chr >> 4) & 0xf]);
       destination->Set(dest_position+5, hex_chars[chr & 0xf]);
@@ skipping 120 matching lines @@
   CONVERT_CHECKED(String, str, args[0]);
 
   // ECMA-262 section 15.1.2.3, empty string is NaN
   double value = StringToDouble(str, ALLOW_TRAILING_JUNK, OS::nan_value());
 
   // Create a number object from the value.
   return HEAP->NumberFromDouble(value);
 }
 
 
-static unibrow::Mapping<unibrow::ToUppercase, 128> to_upper_mapping;
-static unibrow::Mapping<unibrow::ToLowercase, 128> to_lower_mapping;
-
-
 template <class Converter>
-static Object* ConvertCaseHelper(String* s,
+static Object* ConvertCaseHelper(RuntimeState* state,
+                                 String* s,
                                  int length,
                                  int input_string_length,
                                  unibrow::Mapping<Converter, 128>* mapping) {
   // We try this twice, once with the assumption that the result is no longer
   // than the input and, if that assumption breaks, again with the exact
   // length.  This may not be pretty, but it is nicer than what was here before
   // and I hereby claim my vaffel-is.
   //
   // Allocate the resulting string.
   //
   // NOTE: This assumes that the upper/lower case of an ascii
   // character is also ascii.  This is currently the case, but it
   // might break in the future if we implement more context and locale
   // dependent upper/lower conversions.
   Object* o = s->IsAsciiRepresentation()
       ? HEAP->AllocateRawAsciiString(length)
       : HEAP->AllocateRawTwoByteString(length);
   if (o->IsFailure()) return o;
   String* result = String::cast(o);
   bool has_changed_character = false;
 
   // Convert all characters to upper case, assuming that they will fit
   // in the buffer
-  Access<StringInputBuffer> buffer(&runtime_string_input_buffer);
+  Access<StringInputBuffer> buffer(state->string_input_buffer());
   buffer->Reset(s);
   unibrow::uchar chars[Converter::kMaxWidth];
   // We can assume that the string is not empty
   uc32 current = buffer->GetNext();
   for (int i = 0; i < length;) {
     bool has_next = buffer->has_more();
     uc32 next = has_next ? buffer->GetNext() : 0;
     int char_length = mapping->get(current, next, chars);
     if (char_length == 0) {
       // The case conversion of this character is the character itself.
@@ skipping 105 matching lines @@
     }
     return changed;
   }
 };
 
 }  // namespace
 
 
 template <typename ConvertTraits>
 static Object* ConvertCase(
-    Arguments args,
+    RuntimeState* state, Arguments args,
     unibrow::Mapping<typename ConvertTraits::UnibrowConverter, 128>* mapping) {
   NoHandleAllocation ha;
   CONVERT_CHECKED(String, s, args[0]);
   s->TryFlatten();
 
   const int length = s->length();
   // Assume that the string is not empty; we need this assumption later
   if (length == 0) return s;
 
   // Simpler handling of ascii strings.
   //
   // NOTE: This assumes that the upper/lower case of an ascii
   // character is also ascii.  This is currently the case, but it
   // might break in the future if we implement more context and locale
   // dependent upper/lower conversions.
   SeqAsciiString* seq_ascii = TryGetSeqAsciiString(s);
   if (seq_ascii != NULL) {
     Object* o = HEAP->AllocateRawAsciiString(length);
     if (o->IsFailure()) return o;
     SeqAsciiString* result = SeqAsciiString::cast(o);
     bool has_changed_character = ConvertTraits::ConvertAscii(
         result->GetChars(), seq_ascii->GetChars(), length);
     return has_changed_character ? result : s;
   }
 
-  Object* answer = ConvertCaseHelper(s, length, length, mapping);
+  Object* answer = ConvertCaseHelper(state, s, length, length, mapping);
   if (answer->IsSmi()) {
     // Retry with correct length.
-    answer = ConvertCaseHelper(s, Smi::cast(answer)->value(), length, mapping);
+    answer = ConvertCaseHelper(state, s, Smi::cast(answer)->value(), length,
+                               mapping);
   }
   return answer;  // This may be a failure.
 }
 
 
 static Object* Runtime_StringToLowerCase(Arguments args) {
-  return ConvertCase<ToLowerTraits>(args, &to_lower_mapping);
+  RuntimeState* state = Isolate::Current()->runtime_state();
+  return ConvertCase<ToLowerTraits>(state, args, state->to_lower_mapping());
 }
 
 
 static Object* Runtime_StringToUpperCase(Arguments args) {
-  return ConvertCase<ToUpperTraits>(args, &to_upper_mapping);
+  RuntimeState* state = Isolate::Current()->runtime_state();
+  return ConvertCase<ToUpperTraits>(state, args, state->to_upper_mapping());
 }
 
 
 static inline bool IsTrimWhiteSpace(unibrow::uchar c) {
   return unibrow::WhiteSpace::Is(c) || c == 0x200b;
 }
 
 
 static Object* Runtime_StringTrim(Arguments args) {
   NoHandleAllocation ha;
@@ skipping 17 matching lines @@
   if (trimRight) {
     while (right > left && IsTrimWhiteSpace(s->Get(right - 1))) {
       right--;
     }
   }
   return s->SubString(left, right);
 }
 
 
 template <typename schar, typename pchar>
-void FindStringIndices(Vector<const schar> subject,
+void FindStringIndices(RuntimeState* state,
+                       Vector<const schar> subject,
                        Vector<const pchar> pattern,
                        ZoneList<int>* indices,
                        unsigned int limit) {
   ASSERT(limit > 0);
   // Collect indices of pattern in subject, and the end-of-string index.
   // Stop after finding at most limit values.
   StringSearchStrategy strategy =
-      InitializeStringSearch(pattern, sizeof(schar) == 1);
+      InitializeStringSearch(state, pattern, sizeof(schar) == 1);
   switch (strategy) {
     case SEARCH_FAIL: return;
     case SEARCH_SHORT: {
       int pattern_length = pattern.length();
       int index = 0;
       while (limit > 0) {
         index = SimpleIndexOf(subject, pattern, index);
         if (index < 0) return;
         indices->Add(index);
         index += pattern_length;
         limit--;
       }
       return;
     }
     case SEARCH_LONG: {
       int pattern_length = pattern.length();
       int index = 0;
       while (limit > 0) {
-        index = ComplexIndexOf(subject, pattern, index);
+        index = ComplexIndexOf(state, subject, pattern, index);
         if (index < 0) return;
         indices->Add(index);
         index += pattern_length;
         limit--;
       }
       return;
     }
     default:
       UNREACHABLE();
       return;
@@ skipping 13 matching lines @@
     if (index < 0) return;
     indices->Add(index);
     index++;
     limit--;
   }
 }
 
 
 static Object* Runtime_StringSplit(Arguments args) {
   ASSERT(args.length() == 3);
+  Isolate* isolate = Isolate::Current();
   HandleScope handle_scope;
   CONVERT_ARG_CHECKED(String, subject, 0);
   CONVERT_ARG_CHECKED(String, pattern, 1);
   CONVERT_NUMBER_CHECKED(uint32_t, limit, Uint32, args[2]);
 
   int subject_length = subject->length();
   int pattern_length = pattern->length();
   RUNTIME_ASSERT(pattern_length > 0);
 
   // The limit can be very large (0xffffffffu), but since the pattern
   // isn't empty, we can never create more parts than ~half the length
   // of the subject.
 
   if (!subject->IsFlat()) FlattenString(subject);
 
   static const int kMaxInitialListCapacity = 16;
 
   ZoneScope scope(DELETE_ON_EXIT);
 
   // Find (up to limit) indices of separator and end-of-string in subject
   int initial_capacity = Min<uint32_t>(kMaxInitialListCapacity, limit);
   ZoneList<int> indices(initial_capacity);
   if (pattern_length == 1) {
     // Special case, go directly to fast single-character split.
     AssertNoAllocation nogc;
     uc16 pattern_char = pattern->Get(0);
     if (subject->IsTwoByteRepresentation()) {
-      FindCharIndices(subject->ToUC16Vector(), pattern_char,
+      FindCharIndices(subject->ToUC16Vector(),
+                      pattern_char,
                       &indices,
                       limit);
     } else if (pattern_char <= String::kMaxAsciiCharCode) {
       FindCharIndices(subject->ToAsciiVector(),
                       static_cast<char>(pattern_char),
                       &indices,
                       limit);
     }
   } else {
     if (!pattern->IsFlat()) FlattenString(pattern);
     AssertNoAllocation nogc;
     if (subject->IsAsciiRepresentation()) {
       Vector<const char> subject_vector = subject->ToAsciiVector();
       if (pattern->IsAsciiRepresentation()) {
-        FindStringIndices(subject_vector,
+        FindStringIndices(isolate->runtime_state(),
+                          subject_vector,
                           pattern->ToAsciiVector(),
                           &indices,
                           limit);
       } else {
-        FindStringIndices(subject_vector,
+        FindStringIndices(isolate->runtime_state(),
+                          subject_vector,
                           pattern->ToUC16Vector(),
                           &indices,
                           limit);
       }
     } else {
       Vector<const uc16> subject_vector = subject->ToUC16Vector();
       if (pattern->IsAsciiRepresentation()) {
-        FindStringIndices(subject_vector,
+        FindStringIndices(isolate->runtime_state(),
+                          subject_vector,
                           pattern->ToAsciiVector(),
                           &indices,
                           limit);
       } else {
-        FindStringIndices(subject_vector,
+        FindStringIndices(isolate->runtime_state(),
+                          subject_vector,
                           pattern->ToUC16Vector(),
                           &indices,
                           limit);
       }
     }
   }
   if (static_cast<uint32_t>(indices.length()) < limit) {
     indices.Add(subject_length);
   }
   // The list indices now contains the end of each part to create.
@@ skipping 97 matching lines @@
     ASSERT(String::cast(elements->get(i))->length() == 1);
   }
 #endif
 
   return *Factory::NewJSArrayWithElements(elements);
 }
 
 
 bool Runtime::IsUpperCaseChar(uint16_t ch) {
   unibrow::uchar chars[unibrow::ToUppercase::kMaxWidth];
-  int char_length = to_upper_mapping.get(ch, 0, chars);
+  int char_length = Isolate::Current()->runtime_state()->to_upper_mapping()->
+      get(ch, 0, chars);
   return char_length == 0;
 }
 
 
 static Object* Runtime_NumberToString(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
 
   Object* number = args[0];
   RUNTIME_ASSERT(number->IsNumber());
@@ skipping 431 matching lines @@
   return Smi::FromInt(GREATER);
 }
 
 
 // Compare two Smis as if they were converted to strings and then
 // compared lexicographically.
 static Object* Runtime_SmiLexicographicCompare(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 2);
 
-  // Arrays for the individual characters of the two Smis.  Smis are
-  // 31 bit integers and 10 decimal digits are therefore enough.
-  static int x_elms[10];
-  static int y_elms[10];
-
   // Extract the integer values from the Smis.
   CONVERT_CHECKED(Smi, x, args[0]);
   CONVERT_CHECKED(Smi, y, args[1]);
   int x_value = x->value();
   int y_value = y->value();
 
   // If the integers are equal so are the string representations.
   if (x_value == y_value) return Smi::FromInt(EQUAL);
 
   // If one of the integers are zero the normal integer order is the
   // same as the lexicographic order of the string representations.
   if (x_value == 0 || y_value == 0) return Smi::FromInt(x_value - y_value);
 
   // If only one of the integers is negative the negative number is
   // smallest because the char code of '-' is less than the char code
   // of any digit.  Otherwise, we make both values positive.
   if (x_value < 0 || y_value < 0) {
     if (y_value >= 0) return Smi::FromInt(LESS);
     if (x_value >= 0) return Smi::FromInt(GREATER);
     x_value = -x_value;
     y_value = -y_value;
   }
 
+  Isolate* isolate = Isolate::Current();
+  // Arrays for the individual characters of the two Smis.  Smis are
+  // 31 bit integers and 10 decimal digits are therefore enough.
+  int* x_elms = isolate->runtime_state()->smi_lexicographic_compare_x_elms();
+  int* y_elms = isolate->runtime_state()->smi_lexicographic_compare_y_elms();
+
+
   // Convert the integers to arrays of their decimal digits.
   int x_index = 0;
   int y_index = 0;
   while (x_value > 0) {
     x_elms[x_index++] = x_value % 10;
     x_value /= 10;
   }
   while (y_value > 0) {
     y_elms[y_index++] = y_value % 10;
     y_value /= 10;
   }
 
   // Loop through the arrays of decimal digits finding the first place
   // where they differ.
   while (--x_index >= 0 && --y_index >= 0) {
     int diff = x_elms[x_index] - y_elms[y_index];
     if (diff != 0) return Smi::FromInt(diff);
   }
 
   // If one array is a suffix of the other array, the longest array is
   // the representation of the largest of the Smis in the
   // lexicographic ordering.
   return Smi::FromInt(x_index - y_index);
 }
 
 
-static Object* StringInputBufferCompare(String* x, String* y) {
-  static StringInputBuffer bufx;
-  static StringInputBuffer bufy;
+static Object* StringInputBufferCompare(RuntimeState* state, String* x,
+                                        String* y) {
+  StringInputBuffer& bufx = *state->string_input_buffer_compare_bufx();
+  StringInputBuffer& bufy = *state->string_input_buffer_compare_bufy();
   bufx.Reset(x);
   bufy.Reset(y);
   while (bufx.has_more() && bufy.has_more()) {
     int d = bufx.GetNext() - bufy.GetNext();
     if (d < 0) return Smi::FromInt(LESS);
     else if (d > 0) return Smi::FromInt(GREATER);
   }
 
   // x is (non-trivial) prefix of y:
   if (bufy.has_more()) return Smi::FromInt(LESS);
@@ skipping 32 matching lines @@
       Vector<const uc16> y_chars = y->ToUC16Vector();
       r = CompareChars(x_chars.start(), y_chars.start(), prefix_length);
     }
   }
   Object* result;
   if (r == 0) {
     result = equal_prefix_result;
   } else {
     result = (r < 0) ? Smi::FromInt(LESS) : Smi::FromInt(GREATER);
   }
-  ASSERT(result == StringInputBufferCompare(x, y));
+  ASSERT(result == StringInputBufferCompare(Isolate::Current()->runtime_state(),
+                                            x, y));
   return result;
 }
 
 
 static Object* Runtime_StringCompare(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 2);
 
   CONVERT_CHECKED(String, x, args[0]);
   CONVERT_CHECKED(String, y, args[1]);
@@ skipping 12 matching lines @@
   int d = x->Get(0) - y->Get(0);
   if (d < 0) return Smi::FromInt(LESS);
   else if (d > 0) return Smi::FromInt(GREATER);
 
   Object* obj = HEAP->PrepareForCompare(x);
   if (obj->IsFailure()) return obj;
   obj = HEAP->PrepareForCompare(y);
   if (obj->IsFailure()) return obj;
 
   return (x->IsFlat() && y->IsFlat()) ? FlatStringCompare(x, y)
-                                      : StringInputBufferCompare(x, y);
+      : StringInputBufferCompare(Isolate::Current()->runtime_state(), x, y);
 }
 
 
 static Object* Runtime_Math_acos(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
   Counters::math_acos.Increment();
 
   CONVERT_DOUBLE_CHECKED(x, args[0]);
   Isolate* const isolate = Isolate::Current();
@@ skipping 16 matching lines @@
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
   Counters::math_atan.Increment();
 
   CONVERT_DOUBLE_CHECKED(x, args[0]);
   Isolate* const isolate = Isolate::Current();
   return isolate->transcendental_cache()->Get(TranscendentalCache::ATAN, x);
 }
 
 
+static const double kPiDividedBy4 = 0.78539816339744830962;
+
+
 static Object* Runtime_Math_atan2(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 2);
   Counters::math_atan2.Increment();
 
   CONVERT_DOUBLE_CHECKED(x, args[0]);
   CONVERT_DOUBLE_CHECKED(y, args[1]);
   double result;
   if (isinf(x) && isinf(y)) {
     // Make sure that the result in case of two infinite arguments
     // is a multiple of Pi / 4. The sign of the result is determined
     // by the first argument (x) and the sign of the second argument
     // determines the multiplier: one or three.
-    static double kPiDividedBy4 = 0.78539816339744830962;
     int multiplier = (x < 0) ? -1 : 1;
     if (y < 0) multiplier *= 3;
     result = multiplier * kPiDividedBy4;
   } else {
     result = atan2(x, y);
   }
   return HEAP->AllocateHeapNumber(result);
 }
 
 
@@ skipping 614 matching lines @@
 
 static Code* ComputeConstructStub(Handle<JSFunction> function) {
   Handle<Object> prototype = Factory::null_value();
   if (function->has_instance_prototype()) {
     prototype = Handle<Object>(function->instance_prototype());
   }
   if (function->shared()->CanGenerateInlineConstructor(*prototype)) {
     ConstructStubCompiler compiler;
     Object* code = compiler.CompileConstructStub(function->shared());
     if (code->IsFailure()) {
-      return Builtins::builtin(Builtins::JSConstructStubGeneric);
+      return Isolate::Current()->builtins()->builtin(
+          Builtins::JSConstructStubGeneric);
     }
     return Code::cast(code);
   }
 
   return function->shared()->construct_stub();
 }
 
 
 static Object* Runtime_NewObject(Arguments args) {
   HandleScope scope;
@@ skipping 2740 matching lines @@
   AssertNoAllocation no_gc;
   WriteBarrierMode mode = array->GetWriteBarrierMode(no_gc);
   for (int i = 0; i < length; i++) {
     array->set(i, frame->GetParameter(i), mode);
   }
   arguments->set_elements(*array);
   return arguments;
 }
 
 
+static const char* source_str =
+    "(function(arguments,__source__){return eval(__source__);})";
+static const int source_str_length = StrLength(source_str);
+
+
 // Evaluate a piece of JavaScript in the context of a stack frame for
 // debugging. This is accomplished by creating a new context which in its
 // extension part has all the parameters and locals of the function on the
 // stack frame. A function which calls eval with the code to evaluate is then
 // compiled in this context and called in this context. As this context
 // replaces the context of the function on the stack frame a new (empty)
 // function is created as well to be used as the closure for the context.
 // This function and the context acts as replacements for the function on the
 // stack frame presenting the same view of the values of parameters and
 // local variables as if the piece of JavaScript was evaluated at the point
@@ skipping 57 matching lines @@
   // Copy any with contexts present and chain them in front of this context.
   Handle<Context> frame_context(Context::cast(frame->context()));
   Handle<Context> function_context(frame_context->fcontext());
   context = CopyWithContextChain(frame_context, context);
 
   // Wrap the evaluation statement in a new function compiled in the newly
   // created context. The function has one parameter which has to be called
   // 'arguments'. This it to have access to what would have been 'arguments' in
   // the function being debugged.
   // function(arguments,__source__) {return eval(__source__);}
-  static const char* source_str =
-      "(function(arguments,__source__){return eval(__source__);})";
-  static const int source_str_length = StrLength(source_str);
+  ASSERT(source_str_length == StrLength(source_str));
+
   Handle<String> function_source =
       Factory::NewStringFromAscii(Vector<const char>(source_str,
                                                      source_str_length));
   Handle<SharedFunctionInfo> shared =
       Compiler::CompileEval(function_source,
                             context,
                             context->IsGlobalContext(),
                             Compiler::DONT_VALIDATE_JSON);
   if (shared.is_null()) return Failure::Exception();
   Handle<JSFunction> compiled_function =
@@ skipping 926 matching lines @@
 }
 
 
 // ----------------------------------------------------------------------------
 // Implementation of Runtime
 
 #define F(name, nargs, ressize)                                           \
   { #name, FUNCTION_ADDR(Runtime_##name), nargs, \
     static_cast<int>(Runtime::k##name), ressize },
 
-static Runtime::Function Runtime_functions[] = {
+static const Runtime::Function Runtime_functions[] = {
   RUNTIME_FUNCTION_LIST(F)
   { NULL, NULL, 0, -1, 0 }
 };
 
 #undef F
 
 
-Runtime::Function* Runtime::FunctionForId(FunctionId fid) {
+const Runtime::Function* Runtime::FunctionForId(FunctionId fid) {
   ASSERT(0 <= fid && fid < kNofFunctions);
   return &Runtime_functions[fid];
 }
 
 
-Runtime::Function* Runtime::FunctionForName(const char* name) {
-  for (Function* f = Runtime_functions; f->name != NULL; f++) {
+const Runtime::Function* Runtime::FunctionForName(const char* name) {
+  for (const Function* f = Runtime_functions; f->name != NULL; f++) {
     if (strcmp(f->name, name) == 0) {
       return f;
     }
   }
   return NULL;
 }
 
 
 void Runtime::PerformGC(Object* result) {
   Failure* failure = Failure::cast(result);
   if (failure->IsRetryAfterGC()) {
     // Try to do a garbage collection; ignore it if it fails. The C
     // entry stub will throw an out-of-memory exception in that case.
     HEAP->CollectGarbage(failure->requested(), failure->allocation_space());
   } else {
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     Counters::gc_last_resort_from_js.Increment();
     HEAP->CollectAllGarbage(false);
   }
 }
 
 
+InlineRuntimeFunctionsTable::InlineRuntimeFunctionsTable() {
+  // 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.
+  int lut_index = 0;
+#define SETUP_RUNTIME_ENTRIES(Name, argc, resize)                              \
+  entries_[lut_index].method = &CodeGenerator::Generate##Name;                 \
+  entries_[lut_index].name = "_" #Name;                                        \
+  entries_[lut_index++].nargs = argc;
+  INLINE_RUNTIME_FUNCTION_LIST(SETUP_RUNTIME_ENTRIES);
+#undef SETUP_RUNTIME_ENTRIES
+}
+
+
 } }  // namespace v8::internal