Try to fix cross-script global scope

src/runtime.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdlib.h>
 #include <limits>
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
@@ skipping 8891 matching lines @@
   HandleScope scope(isolate);
   ASSERT(args.length() == 2);
 
   CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
   CONVERT_ARG_HANDLE_CHECKED(ScopeInfo, scope_info, 1);
   Handle<Context> result =
       isolate->factory()->NewGlobalContext(function, scope_info);
 
   ASSERT(function->context() == isolate->context());
   ASSERT(function->context()->global_object() == result->global_object());
-  result->global_object()->set_global_context(*result);
-  return *result;
+  GlobalObject* global = result->global_object();
+  Context* first_global_context = global->global_context();
+  if (first_global_context->IsNativeContext()) {
+    // This is the first global context, insert directly.
+    global->set_global_context(*result);
+    return *result;
+  } else {
+    // Insert new context at the top of the chain of global contexts.
+    Context* last_global_context = first_global_context;
+    while (!last_global_context->previous()->IsNativeContext()) {
+      last_global_context = last_global_context->previous();
+    }
+    result->set_previous(last_global_context->previous());
+    last_global_context->set_previous(*result);
+    return first_global_context;
+  }
 }
 
 
 RUNTIME_FUNCTION(Runtime_NewFunctionContext) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 1);
 
   CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
   int length = function->shared()->scope_info()->ContextLength();
   return *isolate->factory()->NewFunctionContext(length, function);
@@ skipping 854 matching lines @@
       }
       done = true;
     }
   }
   return !exit_handled || tokens_match;
 }
 
 
 RUNTIME_FUNCTION(Runtime_CompileString) {
   HandleScope scope(isolate);
-  ASSERT(args.length() == 2);
+  ASSERT(args.length() == 3);
   CONVERT_ARG_HANDLE_CHECKED(String, source, 0);
-  CONVERT_BOOLEAN_ARG_CHECKED(function_literal_only, 1);
+  CONVERT_ARG_HANDLE_CHECKED(JSGlobalProxy, global_proxy, 1);
+  CONVERT_BOOLEAN_ARG_CHECKED(function_literal_only, 2);
 
   // Extract native context.
-  Handle<Context> context(isolate->native_context());
+  Handle<Context> native_context(isolate->native_context());
 
   // Filter cross security context calls.
   if (!TokensMatchForCompileString(isolate)) {
     return isolate->heap()->undefined_value();
   }
 
   // Check if native context allows code generation from
   // strings. Throw an exception if it doesn't.
-  if (context->allow_code_gen_from_strings()->IsFalse() &&
-      !CodeGenerationFromStringsAllowed(isolate, context)) {
+  if (native_context->allow_code_gen_from_strings()->IsFalse() &&
+      !CodeGenerationFromStringsAllowed(isolate, native_context)) {
     Handle<Object> error_message =
-        context->ErrorMessageForCodeGenerationFromStrings();
+        native_context->ErrorMessageForCodeGenerationFromStrings();
     return isolate->Throw(*isolate->factory()->NewEvalError(
         "code_gen_from_strings", HandleVector<Object>(&error_message, 1)));
   }
 
   // Compile source string in the native context.
   ParseRestriction restriction = function_literal_only
       ? ONLY_SINGLE_FUNCTION_LITERAL : NO_PARSE_RESTRICTION;
+//TODO: this is insecure, fix. Need to get the global context properly.
+  Handle<GlobalObject> global(GlobalObject::cast(global_proxy->GetPrototype()));
+  Handle<Context> context(global->global_context());
   Handle<JSFunction> fun;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, fun,
       Compiler::GetFunctionFromEval(
           source, context, SLOPPY, restriction, RelocInfo::kNoPosition));
   return *fun;
 }
 
 
 static ObjectPair CompileGlobalEval(Isolate* isolate,
@@ skipping 1968 matching lines @@
   // Fill all context locals.
   if (!ScopeInfo::CopyContextLocalsToScopeObject(
           scope_info, context, block_scope)) {
     return MaybeHandle<JSObject>();
   }
 
   return block_scope;
 }
 
 
+// Create a plain JSObject which materializes the block scope for the specified
+// global context.
+MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeGlobalScope(
+    Isolate* isolate,
+    Handle<Context> context) {
+  ASSERT(context->IsGlobalContext());
+  Handle<ScopeInfo> scope_info(ScopeInfo::cast(context->extension()));
+
+  // Allocate and initialize a JSObject with all the arguments, stack locals
+  // heap locals and extension properties of the debugged function.
+  Handle<JSObject> global_scope =
+      isolate->factory()->NewJSObject(isolate->object_function());
+
+  // Fill all context locals.
+  if (!ScopeInfo::CopyContextLocalsToScopeObject(
+          scope_info, context, global_scope)) {
+    return MaybeHandle<JSObject>();
+  }
+
+  return global_scope;
+}
+
+
 // Create a plain JSObject which materializes the module scope for the specified
 // module context.
 MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeModuleScope(
     Isolate* isolate,
     Handle<Context> context) {
   ASSERT(context->IsModuleContext());
   Handle<ScopeInfo> scope_info(ScopeInfo::cast(context->extension()));
 
   // Allocate and initialize a JSObject with all the members of the debugged
   // module.
   Handle<JSObject> module_scope =
       isolate->factory()->NewJSObject(isolate->object_function());
 
   // Fill all context locals.
   if (!ScopeInfo::CopyContextLocalsToScopeObject(
           scope_info, context, module_scope)) {
     return MaybeHandle<JSObject>();
   }
 
   return module_scope;
 }
 
 
 // Iterate over the actual scopes visible from a stack frame or from a closure.
 // The iteration proceeds from the innermost visible nested scope outwards.
 // All scopes are backed by an actual context except the local scope,
 // which is inserted "artificially" in the context chain.
 class ScopeIterator {
  public:
+  // This type has to be matched by ScopeType in mirror-debugger.js
   enum ScopeType {
-    ScopeTypeGlobal = 0,
+    ScopeTypeNative,
+    ScopeTypeGlobal,
     ScopeTypeLocal,
     ScopeTypeWith,
     ScopeTypeClosure,
     ScopeTypeCatch,
     ScopeTypeBlock,
     ScopeTypeModule
   };
 
   ScopeIterator(Isolate* isolate,
                 JavaScriptFrame* frame,
@@ skipping 107 matching lines @@
     ASSERT(!failed_);
     return context_.is_null();
   }
 
   bool Failed() { return failed_; }
 
   // Move to the next scope.
   void Next() {
     ASSERT(!failed_);
     ScopeType scope_type = Type();
-    if (scope_type == ScopeTypeGlobal) {
-      // The global scope is always the last in the chain.
+    if (scope_type == ScopeTypeNative) {
+      // The native scope is always the last in the chain.
       ASSERT(context_->IsNativeContext());
       context_ = Handle<Context>();
       return;
     }
     if (nested_scope_chain_.is_empty()) {
       context_ = Handle<Context>(context_->previous(), isolate_);
     } else {
       if (nested_scope_chain_.last()->HasContext()) {
         ASSERT(context_->previous() != NULL);
         context_ = Handle<Context>(context_->previous(), isolate_);
       }
       nested_scope_chain_.RemoveLast();
     }
   }
 
   // Return the type of the current scope.
   ScopeType Type() {
     ASSERT(!failed_);
     if (!nested_scope_chain_.is_empty()) {
       Handle<ScopeInfo> scope_info = nested_scope_chain_.last();
       switch (scope_info->scope_type()) {
         case FUNCTION_SCOPE:
           ASSERT(context_->IsFunctionContext() ||
                  !scope_info->HasContext());
           return ScopeTypeLocal;
         case MODULE_SCOPE:
           ASSERT(context_->IsModuleContext());
           return ScopeTypeModule;
         case GLOBAL_SCOPE:
-          ASSERT(context_->IsNativeContext());
+          ASSERT(context_->IsNativeContext() || context_->IsGlobalContext());
+          return
+              context_->IsNativeContext() ? ScopeTypeNative : ScopeTypeGlobal;
+        case SCRIPT_SCOPE:
+          ASSERT(context_->IsGlobalContext());
           return ScopeTypeGlobal;
         case WITH_SCOPE:
           ASSERT(context_->IsWithContext());
           return ScopeTypeWith;
         case CATCH_SCOPE:
           ASSERT(context_->IsCatchContext());
           return ScopeTypeCatch;
         case BLOCK_SCOPE:
           ASSERT(!scope_info->HasContext() ||
                  context_->IsBlockContext());
           return ScopeTypeBlock;
         case EVAL_SCOPE:
           UNREACHABLE();
       }
     }
     if (context_->IsNativeContext()) {
       ASSERT(context_->global_object()->IsGlobalObject());
+      return ScopeTypeNative;
+    }
+    if (context_->IsGlobalContext()) {
       return ScopeTypeGlobal;
     }
     if (context_->IsFunctionContext()) {
       return ScopeTypeClosure;
     }
     if (context_->IsCatchContext()) {
       return ScopeTypeCatch;
     }
     if (context_->IsBlockContext()) {
       return ScopeTypeBlock;
     }
     if (context_->IsModuleContext()) {
       return ScopeTypeModule;
     }
     ASSERT(context_->IsWithContext());
     return ScopeTypeWith;
   }
 
   // Return the JavaScript object with the content of the current scope.
   MaybeHandle<JSObject> ScopeObject() {
     ASSERT(!failed_);
     switch (Type()) {
+      case ScopeIterator::ScopeTypeNative:
+        return Handle<JSObject>(CurrentContext()->global_object());
       case ScopeIterator::ScopeTypeGlobal:
-        return Handle<JSObject>(CurrentContext()->global_object());
+        return MaterializeGlobalScope(isolate_, CurrentContext());
       case ScopeIterator::ScopeTypeLocal:
         // Materialize the content of the local scope into a JSObject.
         ASSERT(nested_scope_chain_.length() == 1);
         return MaterializeLocalScope(isolate_, frame_, inlined_jsframe_index_);
       case ScopeIterator::ScopeTypeWith:
         // Return the with object.
         return Handle<JSObject>(JSObject::cast(CurrentContext()->extension()));
       case ScopeIterator::ScopeTypeCatch:
         return MaterializeCatchScope(isolate_, CurrentContext());
       case ScopeIterator::ScopeTypeClosure:
         // Materialize the content of the closure scope into a JSObject.
         return MaterializeClosure(isolate_, CurrentContext());
       case ScopeIterator::ScopeTypeBlock:
         return MaterializeBlockScope(isolate_, CurrentContext());
       case ScopeIterator::ScopeTypeModule:
         return MaterializeModuleScope(isolate_, CurrentContext());
     }
     UNREACHABLE();
     return Handle<JSObject>();
   }
 
   bool SetVariableValue(Handle<String> variable_name,
                         Handle<Object> new_value) {
     ASSERT(!failed_);
     switch (Type()) {
+      case ScopeIterator::ScopeTypeNative:
+        break;
       case ScopeIterator::ScopeTypeGlobal:
+        // TODO(2399): should we implement it?
         break;
       case ScopeIterator::ScopeTypeLocal:
         return SetLocalVariableValue(isolate_, frame_, inlined_jsframe_index_,
             variable_name, new_value);
       case ScopeIterator::ScopeTypeWith:
         break;
       case ScopeIterator::ScopeTypeCatch:
         return SetCatchVariableValue(isolate_, CurrentContext(),
             variable_name, new_value);
       case ScopeIterator::ScopeTypeClosure:
@@ skipping 18 matching lines @@
     } else if (context_->IsFunctionContext()) {
       return Handle<ScopeInfo>(context_->closure()->shared()->scope_info());
     }
     return Handle<ScopeInfo>::null();
   }
 
   // Return the context for this scope. For the local context there might not
   // be an actual context.
   Handle<Context> CurrentContext() {
     ASSERT(!failed_);
-    if (Type() == ScopeTypeGlobal ||
-        nested_scope_chain_.is_empty()) {
+    if (Type() == ScopeTypeNative || nested_scope_chain_.is_empty()) {
       return context_;
     } else if (nested_scope_chain_.last()->HasContext()) {
       return context_;
     } else {
       return Handle<Context>();
     }
   }
 
 #ifdef DEBUG
   // Debug print of the content of the current scope.
   void DebugPrint() {
     OFStream os(stdout);
     ASSERT(!failed_);
     switch (Type()) {
+      case ScopeIterator::ScopeTypeNative:
+        os << "Native:\n";
+        CurrentContext()->Print(os);
+        break;
+
       case ScopeIterator::ScopeTypeGlobal:
         os << "Global:\n";
         CurrentContext()->Print(os);
         break;
 
+      case ScopeIterator::ScopeTypeModule:
+        os << "Module:\n";
+        CurrentContext()->Print(os);
+        break;
+
+      case ScopeIterator::ScopeTypeBlock:
+        os << "Block:\n";
+        CurrentContext()->Print(os);
+        break;
+
       case ScopeIterator::ScopeTypeLocal: {
         os << "Local:\n";
         function_->shared()->scope_info()->Print();
         if (!CurrentContext().is_null()) {
           CurrentContext()->Print(os);
           if (CurrentContext()->has_extension()) {
             Handle<Object> extension(CurrentContext()->extension(), isolate_);
             if (extension->IsJSContextExtensionObject()) {
               extension->Print(os);
             }
@@ skipping 16 matching lines @@
       case ScopeIterator::ScopeTypeClosure:
         os << "Closure:\n";
         CurrentContext()->Print(os);
         if (CurrentContext()->has_extension()) {
           Handle<Object> extension(CurrentContext()->extension(), isolate_);
           if (extension->IsJSContextExtensionObject()) {
             extension->Print(os);
           }
         }
         break;
-
-      default:
-        UNREACHABLE();
     }
     PrintF("\n");
   }
 #endif
 
  private:
   Isolate* isolate_;
   JavaScriptFrame* frame_;
   int inlined_jsframe_index_;
   Handle<JSFunction> function_;
@@ skipping 2939 matching lines @@
   }
   return NULL;
 }
 
 
 const Runtime::Function* Runtime::FunctionForId(Runtime::FunctionId id) {
   return &(kIntrinsicFunctions[static_cast<int>(id)]);
 }
 
 } }  // namespace v8::internal