Move serialized scope info from Code object to SharedFunctionInfo.

src/scopeinfo.h

 // Copyright 2006-2008 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 19 matching lines @@
 
 #include "variables.h"
 #include "zone-inl.h"
 
 namespace v8 {
 namespace internal {
 
 // Scope information represents information about a functions's
 // scopes (currently only one, because we don't do any inlining)
 // and the allocation of the scope's variables. Scope information
-// is stored in a compressed form with Code objects and is used
+// is stored in a compressed form in FixedArray objects and is used
 // at runtime (stack dumps, deoptimization, etc.).
 //
 // Historical note: In other VMs built by this team, ScopeInfo was
 // usually called DebugInfo since the information was used (among
 // other things) for on-demand debugging (Self, Smalltalk). However,
 // DebugInfo seems misleading, since this information is primarily used
 // in debugging-unrelated contexts.
 
 // Forward defined as
 // template <class Allocator = FreeStoreAllocationPolicy> class ScopeInfo;
 template<class Allocator>
 class ScopeInfo BASE_EMBEDDED {
  public:
   // Create a ScopeInfo instance from a scope.
   explicit ScopeInfo(Scope* scope);
 
-  // Create a ScopeInfo instance from a Code object.
-  explicit ScopeInfo(Code* code);
+  // Create a ScopeInfo instance from an Object holding the serialized data.
+  explicit ScopeInfo(Object* data);
 
-  // Write the ScopeInfo data into a Code object, and returns the
-  // amount of space that was needed. If no Code object is provided
-  // (NULL handle), Serialize() only returns the amount of space needed.
-  //
-  // This operations requires that the Code object has the correct amount
-  // of space for the ScopeInfo data; otherwise the operation fails (fatal
-  // error). Any existing scope info in the Code object is simply overwritten.
-  int Serialize(Code* code);
+  // Creates a heap object holding the serialized scope info.
+  Handle<Object> Serialize();
 
-  // Garbage collection support for scope info embedded in Code objects.
-  // This code is in ScopeInfo because only here we should have to know
-  // about the encoding.
-  static void IterateScopeInfo(Code* code, ObjectVisitor* v);
+  static Handle<Object> CreateHeapObject(Scope* scope);
 
+  // Serializes empty scope info.
+  static Object* EmptyHeapObject();
 
   // --------------------------------------------------------------------------
   // Lookup
 
   Handle<String> function_name() const  { return function_name_; }
 
   Handle<String> parameter_name(int i) const  { return parameters_[i]; }
   int number_of_parameters() const  { return parameters_.length(); }
 
   Handle<String> stack_slot_name(int i) const  { return stack_slots_[i]; }
   int number_of_stack_slots() const  { return stack_slots_.length(); }
 
   Handle<String> context_slot_name(int i) const {
     return context_slots_[i - Context::MIN_CONTEXT_SLOTS];
   }
   int number_of_context_slots() const {
     int l = context_slots_.length();
     return l == 0 ? 0 : l + Context::MIN_CONTEXT_SLOTS;
   }
 
   Handle<String> LocalName(int i) const;
   int NumberOfLocals() const;
 
   // --------------------------------------------------------------------------
   // The following functions provide quick access to scope info details
   // for runtime routines w/o the need to explicitly create a ScopeInfo
   // object.
   //
   // ScopeInfo is the only class which should have to know about the
-  // encoding of it's information in a Code object, which is why these
+  // encoding of it's information in a FixedArray object, which is why these
   // functions are in this class.
 
   // Does this scope call eval.
-  static bool CallsEval(Code* code);
+  static bool CallsEval(Object* data);
 
   // Return the number of stack slots for code.
-  static int NumberOfStackSlots(Code* code);
+  static int NumberOfStackSlots(Object* data);
 
   // Return the number of context slots for code.
-  static int NumberOfContextSlots(Code* code);
+  static int NumberOfContextSlots(Object* data);
 
   // Return if this has context slots besides MIN_CONTEXT_SLOTS;
-  static bool HasHeapAllocatedLocals(Code* code);
+  static bool HasHeapAllocatedLocals(Object* data);
 
-  // Lookup support for scope info embedded in Code objects. Returns
+  // Lookup support for serialized scope info. Returns the
   // the stack slot index for a given slot name if the slot is
   // present; otherwise returns a value < 0. The name must be a symbol
   // (canonicalized).
-  static int StackSlotIndex(Code* code, String* name);
+  static int StackSlotIndex(Object* data, String* name);
 
-  // Lookup support for scope info embedded in Code objects. Returns the
+  // Lookup support for serialized scope info. Returns the
   // context slot index for a given slot name if the slot is present; otherwise
   // returns a value < 0. The name must be a symbol (canonicalized).
   // If the slot is present and mode != NULL, sets *mode to the corresponding
   // mode for that variable.
-  static int ContextSlotIndex(Code* code, String* name, Variable::Mode* mode);
+  static int ContextSlotIndex(Object* data, String* name, Variable::Mode* mode);
 
-  // Lookup support for scope info embedded in Code objects. Returns the
+  // Lookup support for serialized scope info. Returns the
   // parameter index for a given parameter name if the parameter is present;
   // otherwise returns a value < 0. The name must be a symbol (canonicalized).
-  static int ParameterIndex(Code* code, String* name);
+  static int ParameterIndex(Object* data, String* name);
 
-  // Lookup support for scope info embedded in Code objects. Returns the
+  // Lookup support for serialized scope info. Returns the
   // function context slot index if the function name is present (named
   // function expressions, only), otherwise returns a value < 0. The name
   // must be a symbol (canonicalized).
-  static int FunctionContextSlotIndex(Code* code, String* name);
+  static int FunctionContextSlotIndex(Object* data, String* name);
 
   // --------------------------------------------------------------------------
   // Debugging support
 
 #ifdef DEBUG
   void Print();
 #endif
 
  private:
   Handle<String> function_name_;
   bool calls_eval_;
   List<Handle<String>, Allocator > parameters_;
   List<Handle<String>, Allocator > stack_slots_;
   List<Handle<String>, Allocator > context_slots_;
   List<Variable::Mode, Allocator > context_modes_;
 };
 
-class ZoneScopeInfo: public ScopeInfo<ZoneListAllocationPolicy> {
- public:
-  // Create a ZoneScopeInfo instance from a scope.
-  explicit ZoneScopeInfo(Scope* scope)
-      : ScopeInfo<ZoneListAllocationPolicy>(scope) {}
 
-  // Create a ZoneScopeInfo instance from a Code object.
-  explicit ZoneScopeInfo(Code* code)
-      :  ScopeInfo<ZoneListAllocationPolicy>(code) {}
-};
-
-
-// Cache for mapping (code, property name) into context slot index.
+// Cache for mapping (data, property name) into context slot index.
 // The cache contains both positive and negative results.
 // Slot index equals -1 means the property is absent.
 // Cleared at startup and prior to mark sweep collection.
 class ContextSlotCache {
  public:
-  // Lookup context slot index for (code, name).
+  // Lookup context slot index for (data, name).
   // If absent, kNotFound is returned.
-  static int Lookup(Code* code,
+  static int Lookup(Object* data,
                     String* name,
                     Variable::Mode* mode);
 
   // Update an element in the cache.
-  static void Update(Code* code,
+  static void Update(Object* data,
                      String* name,
                      Variable::Mode mode,
                      int slot_index);
 
   // Clear the cache.
   static void Clear();
 
   static const int kNotFound = -2;
  private:
-  inline static int Hash(Code* code, String* name);
+  inline static int Hash(Object* data, String* name);
 
 #ifdef DEBUG
-  static void ValidateEntry(Code* code,
+  static void ValidateEntry(Object* data,
                             String* name,
                             Variable::Mode mode,
                             int slot_index);
 #endif
 
   static const int kLength = 256;
   struct Key {
-    Code* code;
+    Object* data;
     String* name;
   };
 
   struct Value {
     Value(Variable::Mode mode, int index) {
       ASSERT(ModeField::is_valid(mode));
       ASSERT(IndexField::is_valid(index));
       value_ = ModeField::encode(mode) | IndexField::encode(index);
       ASSERT(mode == this->mode());
       ASSERT(index == this->index());
@@ skipping 16 matching lines @@
   };
 
   static Key keys_[kLength];
   static uint32_t values_[kLength];
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SCOPEINFO_H_