therubyracer 0.7.4 → 0.7.5

data/ext/v8/upstream/{2.1.10 → 2.3.3}/src/runtime.h

@@ -72,6 +72,7 @@ namespace internal {
   F(GetOwnProperty, 2, 1) \
   \
   F(IsExtensible, 1, 1) \
+  F(PreventExtensions, 1, 1)\
   \
   /* Utilities */ \
   F(GetFunctionDelegate, 1, 1) \
@@ -102,6 +103,7 @@ namespace internal {
   F(NumberToString, 1, 1) \
   F(NumberToStringSkipCache, 1, 1) \
   F(NumberToInteger, 1, 1) \
+  F(NumberToIntegerMapMinusZero, 1, 1) \
   F(NumberToJSUint32, 1, 1) \
   F(NumberToJSInt32, 1, 1) \
   F(NumberToSmi, 1, 1) \
@@ -113,6 +115,7 @@ namespace internal {
   F(NumberDiv, 2, 1) \
   F(NumberMod, 2, 1) \
   F(NumberUnaryMinus, 1, 1) \
+  F(NumberAlloc, 0, 1) \
   \
   F(StringAdd, 2, 1) \
   F(StringBuilderConcat, 3, 1) \
@@ -161,7 +164,6 @@ namespace internal {
   \
   /* Strings */ \
   F(StringCharCodeAt, 2, 1) \
-  F(StringCharAt, 2, 1) \
   F(StringIndexOf, 3, 1) \
   F(StringLastIndexOf, 3, 1) \
   F(StringLocaleCompare, 2, 1) \
@@ -222,6 +224,7 @@ namespace internal {
   /* Eval */ \
   F(GlobalReceiver, 1, 1) \
   F(ResolvePossiblyDirectEval, 3, 2) \
+  F(ResolvePossiblyDirectEvalNoLookup, 3, 2) \
   \
   F(SetProperty, -1 /* 3 or 4 */, 1) \
   F(DefineOrRedefineDataProperty, 4, 1) \
@@ -255,6 +258,7 @@ namespace internal {
   /* Statements */ \
   F(NewClosure, 2, 1) \
   F(NewObject, 1, 1) \
+  F(NewObjectFromBound, 2, 1) \
   F(Throw, 1, 1) \
   F(ReThrow, 1, 1) \
   F(ThrowReferenceError, 1, 1) \

data/ext/v8/upstream/{2.1.10 → 2.3.3}/src/runtime.js

@@ -80,10 +80,7 @@ function EQUALS(y) {
     } else {
       // x is not a number, boolean, null or undefined.
       if (y == null) return 1;  // not equal
-      if (IS_OBJECT(y)) {
-        return %_ObjectEquals(x, y) ? 0 : 1;
-      }
-      if (IS_FUNCTION(y)) {
+      if (IS_SPEC_OBJECT(y)) {
         return %_ObjectEquals(x, y) ? 0 : 1;
       }
 
@@ -115,7 +112,7 @@ function STRICT_EQUALS(x) {
 // the result when either (or both) the operands are NaN.
 function COMPARE(x, ncr) {
   var left;
-
+  var right;
   // Fast cases for string, numbers and undefined compares.
   if (IS_STRING(this)) {
     if (IS_STRING(x)) return %_StringCompare(this, x);
@@ -126,14 +123,18 @@ function COMPARE(x, ncr) {
     if (IS_UNDEFINED(x)) return ncr;
     left = this;
   } else if (IS_UNDEFINED(this)) {
+    if (!IS_UNDEFINED(x)) {
+      %ToPrimitive(x, NUMBER_HINT);
+    }
+    return ncr;
+  } else if (IS_UNDEFINED(x)) {
+    %ToPrimitive(this, NUMBER_HINT);
     return ncr;
   } else {
-    if (IS_UNDEFINED(x)) return ncr;
     left = %ToPrimitive(this, NUMBER_HINT);
   }
 
-  // Default implementation.
-  var right = %ToPrimitive(x, NUMBER_HINT);
+  right = %ToPrimitive(x, NUMBER_HINT);
   if (IS_STRING(left) && IS_STRING(right)) {
     return %_StringCompare(left, right);
   } else {
@@ -344,7 +345,7 @@ function DELETE(key) {
 
 // ECMA-262, section 11.8.7, page 54.
 function IN(x) {
-  if (x == null || (!IS_OBJECT(x) && !IS_FUNCTION(x))) {
+  if (!IS_SPEC_OBJECT(x)) {
     throw %MakeTypeError('invalid_in_operator_use', [this, x]);
   }
   return %_IsNonNegativeSmi(this) ? %HasElement(x, this) : %HasProperty(x, %ToString(this));
@@ -362,13 +363,13 @@ function INSTANCE_OF(F) {
   }
 
   // If V is not an object, return false.
-  if (IS_NULL(V) || (!IS_OBJECT(V) && !IS_FUNCTION(V))) {
+  if (!IS_SPEC_OBJECT(V)) {
     return 1;
   }
 
   // Get the prototype of F; if it is not an object, throw an error.
   var O = F.prototype;
-  if (IS_NULL(O) || (!IS_OBJECT(O) && !IS_FUNCTION(O))) {
+  if (!IS_SPEC_OBJECT(O)) {
     throw %MakeTypeError('instanceof_nonobject_proto', [O]);
   }
 
@@ -430,7 +431,7 @@ function APPLY_PREPARE(args) {
   // big enough, but sanity check the value to avoid overflow when
   // multiplying with pointer size.
   if (length > 0x800000) {
-    throw %MakeRangeError('apply_overflow', [length]);
+    throw %MakeRangeError('stack_overflow', []);
   }
 
   if (!IS_FUNCTION(this)) {
@@ -449,7 +450,7 @@ function APPLY_PREPARE(args) {
 
 
 function APPLY_OVERFLOW(length) {
-  throw %MakeRangeError('apply_overflow', [length]);
+  throw %MakeRangeError('stack_overflow', []);
 }
 
 
@@ -482,8 +483,7 @@ function ToPrimitive(x, hint) {
   // Fast case check.
   if (IS_STRING(x)) return x;
   // Normal behavior.
-  if (!IS_OBJECT(x) && !IS_FUNCTION(x)) return x;
-  if (x == null) return x;  // check for null, undefined
+  if (!IS_SPEC_OBJECT(x)) return x;
   if (hint == NO_HINT) hint = (IS_DATE(x)) ? STRING_HINT : NUMBER_HINT;
   return (hint == NUMBER_HINT) ? %DefaultNumber(x) : %DefaultString(x);
 }
@@ -562,20 +562,15 @@ function ToInt32(x) {
 // ES5, section 9.12
 function SameValue(x, y) {
   if (typeof x != typeof y) return false;
-  if (IS_NULL_OR_UNDEFINED(x)) return true;
   if (IS_NUMBER(x)) {
     if (NUMBER_IS_NAN(x) && NUMBER_IS_NAN(y)) return true;
-    // x is +0 and y is -0 or vice versa
-    if (x === 0 && y === 0 && !%_IsSmi(x) && !%_IsSmi(y) &&
-        ((1 / x < 0 && 1 / y > 0) || (1 / x > 0 && 1 / y < 0))) {
+    // x is +0 and y is -0 or vice versa.
+    if (x === 0 && y === 0 && (1 / x) != (1 / y)) {
       return false;
     }
-    return x == y;
+    return x === y;
   }
-  if (IS_STRING(x)) return %StringEquals(x, y);
-  if (IS_BOOLEAN(x))return %NumberEquals(%ToNumber(x),%ToNumber(y));
-
-  return %_ObjectEquals(x, y);
+  return x === y
 }
 
 
@@ -587,13 +582,10 @@ function SameValue(x, y) {
 // Returns if the given x is a primitive value - not an object or a
 // function.
 function IsPrimitive(x) {
-  if (!IS_OBJECT(x) && !IS_FUNCTION(x)) {
-    return true;
-  } else {
-    // Even though the type of null is "object", null is still
-    // considered a primitive value.
-    return IS_NULL(x);
-  }
+  // Even though the type of null is "object", null is still
+  // considered a primitive value. IS_SPEC_OBJECT handles this correctly
+  // (i.e., it will return false if x is null).
+  return !IS_SPEC_OBJECT(x);
 }
 
 

data/ext/v8/upstream/{2.1.10 → 2.3.3}/src/scanner.cc

@@ -200,6 +200,7 @@ void ExternalStringUTF16Buffer<StringType, CharType>::SeekForward(int pos) {
 
 // ----------------------------------------------------------------------------
 // Keyword Matcher
+
 KeywordMatcher::FirstState KeywordMatcher::first_states_[] = {
   { "break",  KEYWORD_PREFIX, Token::BREAK },
   { NULL,     C,              Token::ILLEGAL },
@@ -335,13 +336,12 @@ void KeywordMatcher::Step(uc32 input) {
 // Scanner
 
 Scanner::Scanner(ParserMode pre)
-    : stack_overflow_(false), is_pre_parsing_(pre == PREPARSE) { }
+    : is_pre_parsing_(pre == PREPARSE), stack_overflow_(false) { }
 
 
 void Scanner::Initialize(Handle<String> source,
                          ParserLanguage language) {
-  safe_string_input_buffer_.Reset(source.location());
-  Init(source, &safe_string_input_buffer_, 0, source->length(), language);
+  Init(source, NULL, 0, source->length(), language);
 }
 
 
@@ -356,9 +356,7 @@ void Scanner::Initialize(Handle<String> source,
                          int start_position,
                          int end_position,
                          ParserLanguage language) {
-  safe_string_input_buffer_.Reset(source.location());
-  Init(source, &safe_string_input_buffer_,
-       start_position, end_position, language);
+  Init(source, NULL, start_position, end_position, language);
 }
 
 
@@ -367,6 +365,10 @@ void Scanner::Init(Handle<String> source,
                    int start_position,
                    int end_position,
                    ParserLanguage language) {
+  // Either initialize the scanner from a character stream or from a
+  // string.
+  ASSERT(source.is_null() || stream == NULL);
+
   // Initialize the source buffer.
   if (!source.is_null() && StringShape(*source).IsExternalTwoByte()) {
     two_byte_string_buffer_.Initialize(
@@ -381,6 +383,10 @@ void Scanner::Init(Handle<String> source,
         end_position);
     source_ = &ascii_string_buffer_;
   } else {
+    if (!source.is_null()) {
+      safe_string_input_buffer_.Reset(source.location());
+      stream = &safe_string_input_buffer_;
+    }
     char_stream_buffer_.Initialize(source,
                                    stream,
                                    start_position,

data/ext/v8/upstream/{2.1.10 → 2.3.3}/src/scanner.h

@@ -154,7 +154,12 @@ class KeywordMatcher {
 //  *: Actually "future reserved keywords". These are the only ones we
 //     recognized, the remaining are allowed as identifiers.
  public:
-  KeywordMatcher() : state_(INITIAL), token_(Token::IDENTIFIER) {}
+  KeywordMatcher()
+      : state_(INITIAL),
+        token_(Token::IDENTIFIER),
+        keyword_(NULL),
+        counter_(0),
+        keyword_token_(Token::ILLEGAL) {}
 
   Token::Value token() { return token_; }
 
@@ -206,17 +211,6 @@ class KeywordMatcher {
   // State map for first keyword character range.
   static FirstState first_states_[kFirstCharRangeLength];
 
-  // Current state.
-  State state_;
-  // Token for currently added characters.
-  Token::Value token_;
-
-  // Matching a specific keyword string (there is only one possible valid
-  // keyword with the current prefix).
-  const char* keyword_;
-  int counter_;
-  Token::Value keyword_token_;
-
   // If input equals keyword's character at position, continue matching keyword
   // from that position.
   inline bool MatchKeywordStart(uc32 input,
@@ -246,15 +240,26 @@ class KeywordMatcher {
                            char match,
                            State new_state,
                            Token::Value keyword_token) {
-    if (input == match) {  // Matched "do".
-      state_ = new_state;
-      token_ = keyword_token;
-      return true;
+    if (input != match) {
+      return false;
     }
-    return false;
+    state_ = new_state;
+    token_ = keyword_token;
+    return true;
   }
 
   void Step(uc32 input);
+
+  // Current state.
+  State state_;
+  // Token for currently added characters.
+  Token::Value token_;
+
+  // Matching a specific keyword string (there is only one possible valid
+  // keyword with the current prefix).
+  const char* keyword_;
+  int counter_;
+  Token::Value keyword_token_;
 };
 
 
@@ -362,37 +367,6 @@ class Scanner {
   static const int kNoEndPosition = 1;
 
  private:
-  void Init(Handle<String> source,
-            unibrow::CharacterStream* stream,
-            int start_position, int end_position,
-            ParserLanguage language);
-
-
-  // Different UTF16 buffers used to pull characters from. Based on input one of
-  // these will be initialized as the actual data source.
-  CharacterStreamUTF16Buffer char_stream_buffer_;
-  ExternalStringUTF16Buffer<ExternalTwoByteString, uint16_t>
-      two_byte_string_buffer_;
-  ExternalStringUTF16Buffer<ExternalAsciiString, char> ascii_string_buffer_;
-
-  // Source. Will point to one of the buffers declared above.
-  UTF16Buffer* source_;
-
-  // Used to convert the source string into a character stream when a stream
-  // is not passed to the scanner.
-  SafeStringInputBuffer safe_string_input_buffer_;
-
-  // Buffer to hold literal values (identifiers, strings, numbers)
-  // using 0-terminated UTF-8 encoding.
-  UTF8Buffer literal_buffer_1_;
-  UTF8Buffer literal_buffer_2_;
-
-  bool stack_overflow_;
-  static StaticResource<Utf8Decoder> utf8_decoder_;
-
-  // One Unicode character look-ahead; c0_ < 0 at the end of the input.
-  uc32 c0_;
-
   // The current and look-ahead token.
   struct TokenDesc {
     Token::Value token;
@@ -400,11 +374,10 @@ class Scanner {
     UTF8Buffer* literal_buffer;
   };
 
-  TokenDesc current_;  // desc for current token (as returned by Next())
-  TokenDesc next_;     // desc for next token (one token look-ahead)
-  bool has_line_terminator_before_next_;
-  bool is_pre_parsing_;
-  bool is_parsing_json_;
+  void Init(Handle<String> source,
+            unibrow::CharacterStream* stream,
+            int start_position, int end_position,
+            ParserLanguage language);
 
   // Literal buffer support
   void StartLiteral();
@@ -426,6 +399,7 @@ class Scanner {
       return SkipJavaScriptWhiteSpace();
     }
   }
+
   bool SkipJavaScriptWhiteSpace();
   bool SkipJsonWhiteSpace();
   Token::Value SkipSingleLineComment();
@@ -460,11 +434,13 @@ class Scanner {
   // the integer part is zero), and may include an exponent part (e.g., "e-10").
   // Hexadecimal and octal numbers are not allowed.
   Token::Value ScanJsonNumber();
+
   // A JSON string (production JSONString) is subset of valid JavaScript string
   // literals. The string must only be double-quoted (not single-quoted), and
   // the only allowed backslash-escapes are ", /, \, b, f, n, r, t and
   // four-digit hex escapes (uXXXX). Any other use of backslashes is invalid.
   Token::Value ScanJsonString();
+
   // Used to recognizes one of the literals "true", "false", or "null". These
   // are the only valid JSON identifiers (productions JSONBooleanLiteral,
   // JSONNullLiteral).
@@ -489,6 +465,37 @@ class Scanner {
   // Decodes a unicode escape-sequence which is part of an identifier.
   // If the escape sequence cannot be decoded the result is kBadRune.
   uc32 ScanIdentifierUnicodeEscape();
+
+  TokenDesc current_;  // desc for current token (as returned by Next())
+  TokenDesc next_;     // desc for next token (one token look-ahead)
+  bool has_line_terminator_before_next_;
+  bool is_pre_parsing_;
+  bool is_parsing_json_;
+
+  // Different UTF16 buffers used to pull characters from. Based on input one of
+  // these will be initialized as the actual data source.
+  CharacterStreamUTF16Buffer char_stream_buffer_;
+  ExternalStringUTF16Buffer<ExternalTwoByteString, uint16_t>
+      two_byte_string_buffer_;
+  ExternalStringUTF16Buffer<ExternalAsciiString, char> ascii_string_buffer_;
+
+  // Source. Will point to one of the buffers declared above.
+  UTF16Buffer* source_;
+
+  // Used to convert the source string into a character stream when a stream
+  // is not passed to the scanner.
+  SafeStringInputBuffer safe_string_input_buffer_;
+
+  // Buffer to hold literal values (identifiers, strings, numbers)
+  // using 0-terminated UTF-8 encoding.
+  UTF8Buffer literal_buffer_1_;
+  UTF8Buffer literal_buffer_2_;
+
+  bool stack_overflow_;
+  static StaticResource<Utf8Decoder> utf8_decoder_;
+
+  // One Unicode character look-ahead; c0_ < 0 at the end of the input.
+  uc32 c0_;
 };
 
 } }  // namespace v8::internal

data/ext/v8/upstream/{2.1.10 → 2.3.3}/src/scopeinfo.cc

@@ -148,7 +148,7 @@ ScopeInfo<Allocator>::ScopeInfo(Scope* scope)
 }
 
 
-// Encoding format in the Code object:
+// Encoding format in a FixedArray object:
 //
 // - function name
 //
@@ -204,12 +204,6 @@ static inline Object** ReadSymbol(Object** p, Handle<String>* s) {
 }
 
 
-static inline Object** ReadSentinel(Object** p) {
-  ASSERT(*p == NULL);
-  return p + 1;
-}
-
-
 template <class Allocator>
 static Object** ReadList(Object** p, List<Handle<String>, Allocator >* list) {
   ASSERT(list->is_empty());
@@ -220,7 +214,7 @@ static Object** ReadList(Object** p, List<Handle<String>, Allocator >* list) {
     p = ReadSymbol(p, &s);
     list->Add(s);
   }
-  return ReadSentinel(p);
+  return p;
 }
 
 
@@ -239,27 +233,27 @@ static Object** ReadList(Object** p,
     list->Add(s);
     modes->Add(static_cast<Variable::Mode>(m));
   }
-  return ReadSentinel(p);
+  return p;
 }
 
 
 template<class Allocator>
-ScopeInfo<Allocator>::ScopeInfo(Code* code)
+ScopeInfo<Allocator>::ScopeInfo(SerializedScopeInfo* data)
   : function_name_(Factory::empty_symbol()),
     parameters_(4),
     stack_slots_(8),
     context_slots_(8),
     context_modes_(8) {
-  if (code == NULL || code->sinfo_size() == 0) return;
-
-  Object** p0 = &Memory::Object_at(code->sinfo_start());
-  Object** p = p0;
-  p = ReadSymbol(p, &function_name_);
-  p = ReadBool(p, &calls_eval_);
-  p = ReadList<Allocator>(p, &context_slots_, &context_modes_);
-  p = ReadList<Allocator>(p, &parameters_);
-  p = ReadList<Allocator>(p, &stack_slots_);
-  ASSERT((p - p0) * kPointerSize == code->sinfo_size());
+  if (data->length() > 0) {
+    Object** p0 = data->data_start();
+    Object** p = p0;
+    p = ReadSymbol(p, &function_name_);
+    p = ReadBool(p, &calls_eval_);
+    p = ReadList<Allocator>(p, &context_slots_, &context_modes_);
+    p = ReadList<Allocator>(p, &parameters_);
+    p = ReadList<Allocator>(p, &stack_slots_);
+    ASSERT((p - p0) == FixedArray::cast(data)->length());
+  }
 }
 
 
@@ -281,12 +275,6 @@ static inline Object** WriteSymbol(Object** p, Handle<String> s) {
 }
 
 
-static inline Object** WriteSentinel(Object** p) {
-  *p++ = NULL;
-  return p;
-}
-
-
 template <class Allocator>
 static Object** WriteList(Object** p, List<Handle<String>, Allocator >* list) {
   const int n = list->length();
@@ -294,7 +282,7 @@ static Object** WriteList(Object** p, List<Handle<String>, Allocator >* list) {
   for (int i = 0; i < n; i++) {
     p = WriteSymbol(p, list->at(i));
   }
-  return WriteSentinel(p);
+  return p;
 }
 
 
@@ -308,73 +296,99 @@ static Object** WriteList(Object** p,
     p = WriteSymbol(p, list->at(i));
     p = WriteInt(p, modes->at(i));
   }
-  return WriteSentinel(p);
+  return p;
 }
 
 
 template<class Allocator>
-int ScopeInfo<Allocator>::Serialize(Code* code) {
-  // function name, calls eval, length & sentinel for 3 tables:
-  const int extra_slots = 1 + 1 + 2 * 3;
-  int size = (extra_slots +
-              context_slots_.length() * 2 +
-              parameters_.length() +
-              stack_slots_.length()) * kPointerSize;
-
-  if (code != NULL) {
-    CHECK(code->sinfo_size() == size);
-    Object** p0 = &Memory::Object_at(code->sinfo_start());
-    Object** p = p0;
-    p = WriteSymbol(p, function_name_);
-    p = WriteBool(p, calls_eval_);
-    p = WriteList(p, &context_slots_, &context_modes_);
-    p = WriteList(p, &parameters_);
-    p = WriteList(p, &stack_slots_);
-    ASSERT((p - p0) * kPointerSize == size);
-  }
+Handle<SerializedScopeInfo> ScopeInfo<Allocator>::Serialize() {
+  // function name, calls eval, length for 3 tables:
+  const int extra_slots = 1 + 1 + 3;
+  int length = extra_slots +
+               context_slots_.length() * 2 +
+               parameters_.length() +
+               stack_slots_.length();
+
+  Handle<SerializedScopeInfo> data(
+      SerializedScopeInfo::cast(*Factory::NewFixedArray(length, TENURED)));
+  AssertNoAllocation nogc;
+
+  Object** p0 = data->data_start();
+  Object** p = p0;
+  p = WriteSymbol(p, function_name_);
+  p = WriteBool(p, calls_eval_);
+  p = WriteList(p, &context_slots_, &context_modes_);
+  p = WriteList(p, &parameters_);
+  p = WriteList(p, &stack_slots_);
+  ASSERT((p - p0) == length);
 
-  return size;
+  return data;
 }
 
 
 template<class Allocator>
-void ScopeInfo<Allocator>::IterateScopeInfo(Code* code, ObjectVisitor* v) {
-  Object** start = &Memory::Object_at(code->sinfo_start());
-  Object** end = &Memory::Object_at(code->sinfo_start() + code->sinfo_size());
-  v->VisitPointers(start, end);
+Handle<String> ScopeInfo<Allocator>::LocalName(int i) const {
+  // A local variable can be allocated either on the stack or in the context.
+  // For variables allocated in the context they are always preceded by
+  // Context::MIN_CONTEXT_SLOTS of fixed allocated slots in the context.
+  if (i < number_of_stack_slots()) {
+    return stack_slot_name(i);
+  } else {
+    return context_slot_name(i - number_of_stack_slots() +
+                             Context::MIN_CONTEXT_SLOTS);
+  }
+}
+
+
+template<class Allocator>
+int ScopeInfo<Allocator>::NumberOfLocals() const {
+  int number_of_locals = number_of_stack_slots();
+  if (number_of_context_slots() > 0) {
+    ASSERT(number_of_context_slots() >= Context::MIN_CONTEXT_SLOTS);
+    number_of_locals += number_of_context_slots() - Context::MIN_CONTEXT_SLOTS;
+  }
+  return number_of_locals;
 }
 
 
-static Object** ContextEntriesAddr(Code* code) {
-  ASSERT(code->sinfo_size() > 0);
-  // +2 for function name and calls eval:
-  return &Memory::Object_at(code->sinfo_start()) + 2;
+Handle<SerializedScopeInfo> SerializedScopeInfo::Create(Scope* scope) {
+  ScopeInfo<ZoneListAllocationPolicy> sinfo(scope);
+  return sinfo.Serialize();
 }
 
 
-static Object** ParameterEntriesAddr(Code* code) {
-  ASSERT(code->sinfo_size() > 0);
-  Object** p = ContextEntriesAddr(code);
-  int n;  // number of context slots;
-  p = ReadInt(p, &n);
-  return p + n*2 + 1;  // *2 for pairs, +1 for sentinel
+SerializedScopeInfo* SerializedScopeInfo::Empty() {
+  return reinterpret_cast<SerializedScopeInfo*>(Heap::empty_fixed_array());
 }
 
 
-static Object** StackSlotEntriesAddr(Code* code) {
-  ASSERT(code->sinfo_size() > 0);
-  Object** p = ParameterEntriesAddr(code);
-  int n;  // number of parameter slots;
-  p = ReadInt(p, &n);
-  return p + n + 1;  // +1 for sentinel
+Object** SerializedScopeInfo::ContextEntriesAddr() {
+  ASSERT(length() > 0);
+  return data_start() + 2;  // +2 for function name and calls eval.
 }
 
 
-template<class Allocator>
-bool ScopeInfo<Allocator>::CallsEval(Code* code) {
-  if (code->sinfo_size() > 0) {
-    // +1 for function name:
-    Object** p = &Memory::Object_at(code->sinfo_start()) + 1;
+Object** SerializedScopeInfo::ParameterEntriesAddr() {
+  ASSERT(length() > 0);
+  Object** p = ContextEntriesAddr();
+  int number_of_context_slots;
+  p = ReadInt(p, &number_of_context_slots);
+  return p + number_of_context_slots*2;  // *2 for pairs
+}
+
+
+Object** SerializedScopeInfo::StackSlotEntriesAddr() {
+  ASSERT(length() > 0);
+  Object** p = ParameterEntriesAddr();
+  int number_of_parameter_slots;
+  p = ReadInt(p, &number_of_parameter_slots);
+  return p + number_of_parameter_slots;
+}
+
+
+bool SerializedScopeInfo::CallsEval() {
+  if (length() > 0) {
+    Object** p = data_start() + 1;  // +1 for function name.
     bool calls_eval;
     p = ReadBool(p, &calls_eval);
     return calls_eval;
@@ -383,41 +397,49 @@ bool ScopeInfo<Allocator>::CallsEval(Code* code) {
 }
 
 
-template<class Allocator>
-int ScopeInfo<Allocator>::NumberOfStackSlots(Code* code) {
-  if (code->sinfo_size() > 0) {
-    Object** p = StackSlotEntriesAddr(code);
-    int n;  // number of stack slots;
-    ReadInt(p, &n);
-    return n;
+int SerializedScopeInfo::NumberOfStackSlots() {
+  if (length() > 0) {
+    Object** p = StackSlotEntriesAddr();
+    int number_of_stack_slots;
+    ReadInt(p, &number_of_stack_slots);
+    return number_of_stack_slots;
   }
   return 0;
 }
 
 
-template<class Allocator>
-int ScopeInfo<Allocator>::NumberOfContextSlots(Code* code) {
-  if (code->sinfo_size() > 0) {
-    Object** p = ContextEntriesAddr(code);
-    int n;  // number of context slots;
-    ReadInt(p, &n);
-    return n + Context::MIN_CONTEXT_SLOTS;
+int SerializedScopeInfo::NumberOfContextSlots() {
+  if (length() > 0) {
+    Object** p = ContextEntriesAddr();
+    int number_of_context_slots;
+    ReadInt(p, &number_of_context_slots);
+    return number_of_context_slots + Context::MIN_CONTEXT_SLOTS;
   }
   return 0;
 }
 
 
-template<class Allocator>
-int ScopeInfo<Allocator>::StackSlotIndex(Code* code, String* name) {
+bool SerializedScopeInfo::HasHeapAllocatedLocals() {
+  if (length() > 0) {
+    Object** p = ContextEntriesAddr();
+    int number_of_context_slots;
+    ReadInt(p, &number_of_context_slots);
+    return number_of_context_slots > 0;
+  }
+  return false;
+}
+
+
+int SerializedScopeInfo::StackSlotIndex(String* name) {
   ASSERT(name->IsSymbol());
-  if (code->sinfo_size() > 0) {
-    // Loop below depends on the NULL sentinel after the stack slot names.
-    ASSERT(NumberOfStackSlots(code) > 0 ||
-           *(StackSlotEntriesAddr(code) + 1) == NULL);
-    // slots start after length entry
-    Object** p0 = StackSlotEntriesAddr(code) + 1;
+  if (length() > 0) {
+    // Slots start after length entry.
+    Object** p0 = StackSlotEntriesAddr();
+    int number_of_stack_slots;
+    p0 = ReadInt(p0, &number_of_stack_slots);
     Object** p = p0;
-    while (*p != NULL) {
+    Object** end = p0 + number_of_stack_slots;
+    while (p != end) {
       if (*p == name) return static_cast<int>(p - p0);
       p++;
     }
@@ -425,24 +447,18 @@ int ScopeInfo<Allocator>::StackSlotIndex(Code* code, String* name) {
   return -1;
 }
 
-
-template<class Allocator>
-int ScopeInfo<Allocator>::ContextSlotIndex(Code* code,
-                                           String* name,
-                                           Variable::Mode* mode) {
+int SerializedScopeInfo::ContextSlotIndex(String* name, Variable::Mode* mode) {
   ASSERT(name->IsSymbol());
-  int result = ContextSlotCache::Lookup(code, name, mode);
+  int result = ContextSlotCache::Lookup(this, name, mode);
   if (result != ContextSlotCache::kNotFound) return result;
-  if (code->sinfo_size() > 0) {
-    // Loop below depends on the NULL sentinel after the context slot names.
-    ASSERT(NumberOfContextSlots(code) >= Context::MIN_CONTEXT_SLOTS ||
-           *(ContextEntriesAddr(code) + 1) == NULL);
-
-    // slots start after length entry
-    Object** p0 = ContextEntriesAddr(code) + 1;
+  if (length() > 0) {
+    // Slots start after length entry.
+    Object** p0 = ContextEntriesAddr();
+    int number_of_context_slots;
+    p0 = ReadInt(p0, &number_of_context_slots);
     Object** p = p0;
-    // contexts may have no variable slots (in the presence of eval()).
-    while (*p != NULL) {
+    Object** end = p0 + number_of_context_slots * 2;
+    while (p != end) {
       if (*p == name) {
         ASSERT(((p - p0) & 1) == 0);
         int v;
@@ -450,21 +466,20 @@ int ScopeInfo<Allocator>::ContextSlotIndex(Code* code,
         Variable::Mode mode_value = static_cast<Variable::Mode>(v);
         if (mode != NULL) *mode = mode_value;
         result = static_cast<int>((p - p0) >> 1) + Context::MIN_CONTEXT_SLOTS;
-        ContextSlotCache::Update(code, name, mode_value, result);
+        ContextSlotCache::Update(this, name, mode_value, result);
         return result;
       }
       p += 2;
     }
   }
-  ContextSlotCache::Update(code, name, Variable::INTERNAL, -1);
+  ContextSlotCache::Update(this, name, Variable::INTERNAL, -1);
   return -1;
 }
 
 
-template<class Allocator>
-int ScopeInfo<Allocator>::ParameterIndex(Code* code, String* name) {
+int SerializedScopeInfo::ParameterIndex(String* name) {
   ASSERT(name->IsSymbol());
-  if (code->sinfo_size() > 0) {
+  if (length() > 0) {
     // We must read parameters from the end since for
     // multiply declared parameters the value of the
     // last declaration of that parameter is used
@@ -475,10 +490,10 @@ int ScopeInfo<Allocator>::ParameterIndex(Code* code, String* name) {
     // once, with corresponding index. This requires a new
     // implementation of the ScopeInfo code. See also other
     // comments in this file regarding this.
-    Object** p = ParameterEntriesAddr(code);
-    int n;  // number of parameters
-    Object** p0 = ReadInt(p, &n);
-    p = p0 + n;
+    Object** p = ParameterEntriesAddr();
+    int number_of_parameter_slots;
+    Object** p0 = ReadInt(p, &number_of_parameter_slots);
+    p = p0 + number_of_parameter_slots;
     while (p > p0) {
       p--;
       if (*p == name) return static_cast<int>(p - p0);
@@ -488,64 +503,37 @@ int ScopeInfo<Allocator>::ParameterIndex(Code* code, String* name) {
 }
 
 
-template<class Allocator>
-int ScopeInfo<Allocator>::FunctionContextSlotIndex(Code* code, String* name) {
+int SerializedScopeInfo::FunctionContextSlotIndex(String* name) {
   ASSERT(name->IsSymbol());
-  if (code->sinfo_size() > 0) {
-    Object** p = &Memory::Object_at(code->sinfo_start());
+  if (length() > 0) {
+    Object** p = data_start();
     if (*p == name) {
-      p = ContextEntriesAddr(code);
-      int n;  // number of context slots
-      ReadInt(p, &n);
-      ASSERT(n != 0);
+      p = ContextEntriesAddr();
+      int number_of_context_slots;
+      ReadInt(p, &number_of_context_slots);
+      ASSERT(number_of_context_slots != 0);
       // The function context slot is the last entry.
-      return n + Context::MIN_CONTEXT_SLOTS - 1;
+      return number_of_context_slots + Context::MIN_CONTEXT_SLOTS - 1;
     }
   }
   return -1;
 }
 
 
-template<class Allocator>
-Handle<String> ScopeInfo<Allocator>::LocalName(int i) const {
-  // A local variable can be allocated either on the stack or in the context.
-  // For variables allocated in the context they are always preceded by the
-  // number Context::MIN_CONTEXT_SLOTS number of fixed allocated slots in the
-  // context.
-  if (i < number_of_stack_slots()) {
-    return stack_slot_name(i);
-  } else {
-    return context_slot_name(i - number_of_stack_slots() +
-                             Context::MIN_CONTEXT_SLOTS);
-  }
-}
-
-
-template<class Allocator>
-int ScopeInfo<Allocator>::NumberOfLocals() const {
-  int number_of_locals = number_of_stack_slots();
-  if (number_of_context_slots() > 0) {
-    ASSERT(number_of_context_slots() >= Context::MIN_CONTEXT_SLOTS);
-    number_of_locals += number_of_context_slots() - Context::MIN_CONTEXT_SLOTS;
-  }
-  return number_of_locals;
-}
-
-
-int ContextSlotCache::Hash(Code* code, String* name) {
+int ContextSlotCache::Hash(Object* data, String* name) {
   // Uses only lower 32 bits if pointers are larger.
   uintptr_t addr_hash =
-      static_cast<uint32_t>(reinterpret_cast<uintptr_t>(code)) >> 2;
+      static_cast<uint32_t>(reinterpret_cast<uintptr_t>(data)) >> 2;
   return static_cast<int>((addr_hash ^ name->Hash()) % kLength);
 }
 
 
-int ContextSlotCache::Lookup(Code* code,
+int ContextSlotCache::Lookup(Object* data,
                              String* name,
                              Variable::Mode* mode) {
-  int index = Hash(code, name);
+  int index = Hash(data, name);
   Key& key = keys_[index];
-  if ((key.code == code) && key.name->Equals(name)) {
+  if ((key.data == data) && key.name->Equals(name)) {
     Value result(values_[index]);
     if (mode != NULL) *mode = result.mode();
     return result.index() + kNotFound;
@@ -554,28 +542,28 @@ int ContextSlotCache::Lookup(Code* code,
 }
 
 
-void ContextSlotCache::Update(Code* code,
+void ContextSlotCache::Update(Object* data,
                               String* name,
                               Variable::Mode mode,
                               int slot_index) {
   String* symbol;
   ASSERT(slot_index > kNotFound);
   if (Heap::LookupSymbolIfExists(name, &symbol)) {
-    int index = Hash(code, symbol);
+    int index = Hash(data, symbol);
     Key& key = keys_[index];
-    key.code = code;
+    key.data = data;
     key.name = symbol;
     // Please note value only takes a uint as index.
     values_[index] = Value(mode, slot_index - kNotFound).raw();
 #ifdef DEBUG
-    ValidateEntry(code, name, mode, slot_index);
+    ValidateEntry(data, name, mode, slot_index);
 #endif
   }
 }
 
 
 void ContextSlotCache::Clear() {
-  for (int index = 0; index < kLength; index++) keys_[index].code = NULL;
+  for (int index = 0; index < kLength; index++) keys_[index].data = NULL;
 }
 
 
@@ -587,15 +575,15 @@ uint32_t ContextSlotCache::values_[ContextSlotCache::kLength];
 
 #ifdef DEBUG
 
-void ContextSlotCache::ValidateEntry(Code* code,
+void ContextSlotCache::ValidateEntry(Object* data,
                                      String* name,
                                      Variable::Mode mode,
                                      int slot_index) {
   String* symbol;
   if (Heap::LookupSymbolIfExists(name, &symbol)) {
-    int index = Hash(code, name);
+    int index = Hash(data, name);
     Key& key = keys_[index];
-    ASSERT(key.code == code);
+    ASSERT(key.data == data);
     ASSERT(key.name->Equals(name));
     Value result(values_[index]);
     ASSERT(result.mode() == mode);