Move serialized scope info from Code object to SharedFunctionInfo.

src/contexts.cc

 // 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 102 matching lines @@
           PrintF("=> found property in context object %p\n", *extension);
         }
         return extension;
       }
     }
 
     if (context->is_function_context()) {
       // we have context-local slots
 
       // check non-parameter locals in context
-      Handle<Code> code(context->closure()->code());
+      Handle<Object> scope_info(context->closure()->shared()->scope_info());
       Variable::Mode mode;
-      int index = ScopeInfo<>::ContextSlotIndex(*code, *name, &mode);
+      int index = ScopeInfo<>::ContextSlotIndex(*scope_info, *name, &mode);
       ASSERT(index < 0 || index >= MIN_CONTEXT_SLOTS);
       if (index >= 0) {
         // slot found
         if (FLAG_trace_contexts) {
           PrintF("=> found local in context slot %d (mode = %d)\n",
                  index, mode);
         }
         *index_ = index;
         // Note: Fixed context slots are statically allocated by the compiler.
         // Statically allocated variables always have a statically known mode,
         // which is the mode with which they were declared when added to the
         // scope. Thus, the DYNAMIC mode (which corresponds to dynamically
         // declared variables that were introduced through declaration nodes)
         // must not appear here.
         switch (mode) {
           case Variable::INTERNAL:  // fall through
           case Variable::VAR: *attributes = NONE; break;
           case Variable::CONST: *attributes = READ_ONLY; break;
           case Variable::DYNAMIC: UNREACHABLE(); break;
           case Variable::DYNAMIC_GLOBAL: UNREACHABLE(); break;
           case Variable::DYNAMIC_LOCAL: UNREACHABLE(); break;
           case Variable::TEMPORARY: UNREACHABLE(); break;
         }
         return context;
       }
 
       // check parameter locals in context
-      int param_index = ScopeInfo<>::ParameterIndex(*code, *name);
+      int param_index = ScopeInfo<>::ParameterIndex(*scope_info, *name);
       if (param_index >= 0) {
         // slot found.
         int index =
-            ScopeInfo<>::ContextSlotIndex(*code,
+            ScopeInfo<>::ContextSlotIndex(*scope_info,
                                           Heap::arguments_shadow_symbol(),
                                           NULL);
         ASSERT(index >= 0);  // arguments must exist and be in the heap context
         Handle<JSObject> arguments(JSObject::cast(context->get(index)));
         ASSERT(arguments->HasLocalProperty(Heap::length_symbol()));
         if (FLAG_trace_contexts) {
           PrintF("=> found parameter %d in arguments object\n", param_index);
         }
         *index_ = param_index;
         *attributes = NONE;
         return arguments;
       }
 
       // check intermediate context (holding only the function name variable)
       if (follow_context_chain) {
-        int index = ScopeInfo<>::FunctionContextSlotIndex(*code, *name);
+        int index = ScopeInfo<>::FunctionContextSlotIndex(*scope_info, *name);
         if (index >= 0) {
           // slot found
           if (FLAG_trace_contexts) {
             PrintF("=> found intermediate function in context slot %d\n",
                    index);
           }
           *index_ = index;
           *attributes = READ_ONLY;
           return context;
         }
@@ skipping 25 matching lines @@
   // before the global context and check that there are no context
   // extension objects (conservative check for with statements).
   while (!context->IsGlobalContext()) {
     // Check if the context is a potentially a with context.
     if (context->has_extension()) return false;
 
     // Not a with context so it must be a function context.
     ASSERT(context->is_function_context());
 
     // Check non-parameter locals.
-    Handle<Code> code(context->closure()->code());
+    Handle<Object> scope_info(context->closure()->shared()->scope_info());
     Variable::Mode mode;
-    int index = ScopeInfo<>::ContextSlotIndex(*code, *name, &mode);
+    int index = ScopeInfo<>::ContextSlotIndex(*scope_info, *name, &mode);
     ASSERT(index < 0 || index >= MIN_CONTEXT_SLOTS);
     if (index >= 0) return false;
 
     // Check parameter locals.
-    int param_index = ScopeInfo<>::ParameterIndex(*code, *name);
+    int param_index = ScopeInfo<>::ParameterIndex(*scope_info, *name);
     if (param_index >= 0) return false;
 
     // Check context only holding the function name variable.
-    index = ScopeInfo<>::FunctionContextSlotIndex(*code, *name);
+    index = ScopeInfo<>::FunctionContextSlotIndex(*scope_info, *name);
     if (index >= 0) return false;
     context = Context::cast(context->closure()->context());
   }
 
   // No local or potential with statement found so the variable is
   // global unless it is shadowed by an eval-introduced variable.
   return true;
 }
 
 
 #ifdef DEBUG
 bool Context::IsBootstrappingOrContext(Object* object) {
   // During bootstrapping we allow all objects to pass as
   // contexts. This is necessary to fix circular dependencies.
   return Bootstrapper::IsActive() || object->IsContext();
 }
 
 
 bool Context::IsBootstrappingOrGlobalObject(Object* object) {
   // During bootstrapping we allow all objects to pass as global
   // objects. This is necessary to fix circular dependencies.
   return Bootstrapper::IsActive() || object->IsGlobalObject();
 }
 #endif
 
 } }  // namespace v8::internal