2014-03-31 12:01:02 +00:00
|
|
|
// Copyright 2014 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.
|
2008-07-03 15:10:15 +00:00
|
|
|
|
|
|
|
#ifndef V8_BOOTSTRAPPER_H_
|
|
|
|
#define V8_BOOTSTRAPPER_H_
|
|
|
|
|
2014-06-03 08:12:43 +00:00
|
|
|
#include "src/factory.h"
|
2017-05-29 13:24:32 +00:00
|
|
|
#include "src/objects/shared-function-info.h"
|
2017-04-11 05:46:46 +00:00
|
|
|
#include "src/snapshot/natives.h"
|
2017-04-25 13:32:18 +00:00
|
|
|
#include "src/visitors.h"
|
2011-05-06 06:50:20 +00:00
|
|
|
|
2009-05-25 10:05:56 +00:00
|
|
|
namespace v8 {
|
|
|
|
namespace internal {
|
2008-07-03 15:10:15 +00:00
|
|
|
|
2011-03-18 20:35:07 +00:00
|
|
|
// A SourceCodeCache uses a FixedArray to store pairs of
|
2014-09-10 12:38:12 +00:00
|
|
|
// (OneByteString*, JSFunction*), mapping names of native code files
|
2017-04-15 00:25:59 +00:00
|
|
|
// (array.js, etc.) to precompiled functions. Instead of mapping
|
2011-03-18 20:35:07 +00:00
|
|
|
// names to functions it might make sense to let the JS2C tool
|
|
|
|
// generate an index for each native JS file.
|
2015-04-20 13:08:11 +00:00
|
|
|
class SourceCodeCache final BASE_EMBEDDED {
|
2010-03-23 11:40:38 +00:00
|
|
|
public:
|
2011-03-18 20:35:07 +00:00
|
|
|
explicit SourceCodeCache(Script::Type type): type_(type), cache_(NULL) { }
|
2011-03-18 18:49:56 +00:00
|
|
|
|
2013-09-11 08:39:38 +00:00
|
|
|
void Initialize(Isolate* isolate, bool create_heap_objects) {
|
|
|
|
cache_ = create_heap_objects ? isolate->heap()->empty_fixed_array() : NULL;
|
2011-03-18 20:35:07 +00:00
|
|
|
}
|
|
|
|
|
2017-04-25 13:32:18 +00:00
|
|
|
void Iterate(RootVisitor* v) {
|
|
|
|
v->VisitRootPointer(Root::kExtensions,
|
|
|
|
bit_cast<Object**, FixedArray**>(&cache_));
|
2011-03-18 20:35:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool Lookup(Vector<const char> name, Handle<SharedFunctionInfo>* handle) {
|
|
|
|
for (int i = 0; i < cache_->length(); i+=2) {
|
2012-11-15 13:31:27 +00:00
|
|
|
SeqOneByteString* str = SeqOneByteString::cast(cache_->get(i));
|
2013-01-09 10:30:54 +00:00
|
|
|
if (str->IsUtf8EqualTo(name)) {
|
2011-03-18 20:35:07 +00:00
|
|
|
*handle = Handle<SharedFunctionInfo>(
|
|
|
|
SharedFunctionInfo::cast(cache_->get(i + 1)));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Add(Vector<const char> name, Handle<SharedFunctionInfo> shared) {
|
2013-06-04 10:30:05 +00:00
|
|
|
Isolate* isolate = shared->GetIsolate();
|
|
|
|
Factory* factory = isolate->factory();
|
|
|
|
HandleScope scope(isolate);
|
2011-03-18 20:35:07 +00:00
|
|
|
int length = cache_->length();
|
2013-06-04 10:30:05 +00:00
|
|
|
Handle<FixedArray> new_array = factory->NewFixedArray(length + 2, TENURED);
|
2011-03-18 20:35:07 +00:00
|
|
|
cache_->CopyTo(0, *new_array, 0, cache_->length());
|
|
|
|
cache_ = *new_array;
|
2014-04-17 13:27:02 +00:00
|
|
|
Handle<String> str =
|
2017-03-17 17:52:50 +00:00
|
|
|
factory
|
|
|
|
->NewStringFromOneByte(Vector<const uint8_t>::cast(name), TENURED)
|
|
|
|
.ToHandleChecked();
|
2014-08-04 11:34:54 +00:00
|
|
|
DCHECK(!str.is_null());
|
2011-03-18 20:35:07 +00:00
|
|
|
cache_->set(length, *str);
|
|
|
|
cache_->set(length + 1, *shared);
|
2015-09-28 13:10:13 +00:00
|
|
|
Script::cast(shared->script())->set_type(type_);
|
2011-03-18 20:35:07 +00:00
|
|
|
}
|
2010-03-23 11:40:38 +00:00
|
|
|
|
|
|
|
private:
|
2011-03-18 20:35:07 +00:00
|
|
|
Script::Type type_;
|
|
|
|
FixedArray* cache_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(SourceCodeCache);
|
2010-03-23 11:40:38 +00:00
|
|
|
};
|
|
|
|
|
2016-06-27 12:49:51 +00:00
|
|
|
enum GlobalContextType { FULL_CONTEXT, DEBUG_CONTEXT };
|
2010-03-23 11:40:38 +00:00
|
|
|
|
2008-07-03 15:10:15 +00:00
|
|
|
// The Boostrapper is the public interface for creating a JavaScript global
|
|
|
|
// context.
|
2015-04-20 13:08:11 +00:00
|
|
|
class Bootstrapper final {
|
2008-07-03 15:10:15 +00:00
|
|
|
public:
|
2013-05-21 12:03:49 +00:00
|
|
|
static void InitializeOncePerProcess();
|
2014-01-17 10:52:00 +00:00
|
|
|
static void TearDownExtensions();
|
2013-05-21 12:03:49 +00:00
|
|
|
|
2012-01-13 13:09:52 +00:00
|
|
|
// Requires: Heap::SetUp has been called.
|
2011-03-18 20:35:07 +00:00
|
|
|
void Initialize(bool create_heap_objects);
|
|
|
|
void TearDown();
|
2008-07-03 15:10:15 +00:00
|
|
|
|
|
|
|
// Creates a JavaScript Global Context with initial object graph.
|
|
|
|
// The returned value is a global handle casted to V8Environment*.
|
2011-03-18 20:35:07 +00:00
|
|
|
Handle<Context> CreateEnvironment(
|
2014-07-01 12:12:34 +00:00
|
|
|
MaybeHandle<JSGlobalProxy> maybe_global_proxy,
|
2015-07-06 07:09:07 +00:00
|
|
|
v8::Local<v8::ObjectTemplate> global_object_template,
|
2016-06-15 15:38:40 +00:00
|
|
|
v8::ExtensionConfiguration* extensions, size_t context_snapshot_index,
|
2017-03-17 13:26:05 +00:00
|
|
|
v8::DeserializeEmbedderFieldsCallback embedder_fields_deserializer,
|
2016-02-02 07:25:30 +00:00
|
|
|
GlobalContextType context_type = FULL_CONTEXT);
|
2015-07-13 09:45:43 +00:00
|
|
|
|
2016-07-07 19:37:05 +00:00
|
|
|
Handle<JSGlobalProxy> NewRemoteContext(
|
|
|
|
MaybeHandle<JSGlobalProxy> maybe_global_proxy,
|
|
|
|
v8::Local<v8::ObjectTemplate> global_object_template);
|
|
|
|
|
Split window support from V8.
Here is a description of the background and design of split window in Chrome and V8:
https://docs.google.com/a/google.com/Doc?id=chhjkpg_47fwddxbfr
This change list splits the window object into two parts: 1) an inner window object used as the global object of contexts; 2) an outer window object exposed to JavaScript and accessible by the name 'window'. Firefox did it awhile ago, here are some discussions: https://wiki.mozilla.org/Gecko:SplitWindow. One additional benefit of splitting window in Chrome is that accessing global variables don't need security checks anymore, it can improve applications that use many global variables.
V8 support of split window:
There are a small number of changes on V8 api to support split window:
Security context is removed from V8, so does related API functions;
A global object can be detached from its context and reused by a new context;
Access checks on an object template can be turned on/off by default;
An object can turn on its access checks later;
V8 has a new object type, ApiGlobalObject, which is the outer window object type. The existing JSGlobalObject becomes the inner window object type. Security checks are moved from JSGlobalObject to ApiGlobalObject. ApiGlobalObject is the one exposed to JavaScript, it is accessible through Context::Global(). ApiGlobalObject's prototype is set to JSGlobalObject so that property lookups are forwarded to JSGlobalObject. ApiGlobalObject forwards all other property access requests to JSGlobalObject, such as SetProperty, DeleteProperty, etc.
Security token is moved to a global context, and ApiGlobalObject has a reference to its global context. JSGlobalObject has a reference to its global context as well. When accessing properties on a global object in JavaScript, the domain security check is performed by comparing the security token of the lexical context (Top::global_context()) to the token of global object's context. The check is only needed when the receiver is a window object, such as 'window.document'. Accessing global variables, such as 'var foo = 3; foo' does not need checks because the receiver is the inner window object.
When an outer window is detached from its global context (when a frame navigates away from a page), it is completely detached from the inner window. A new context is created for the new page, and the outer global object is reused. At this point, the access check on the DOMWindow wrapper of the old context is turned on. The code in old context is still able to access DOMWindow properties, but it has to go through domain security checks.
It is debatable on how to implement the outer window object. Currently each property access function has to check if the receiver is ApiGlobalObject type. This approach might be error-prone that one may forget to check the receiver when adding new functions. It is unlikely a performance issue because accessing global variables are more common than 'window.foo' style coding.
I am still working on the ARM port, and I'd like to hear comments and suggestions on the best way to support it in V8.
Review URL: http://codereview.chromium.org/7366
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@540 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2008-10-21 19:07:58 +00:00
|
|
|
// Detach the environment from its outer global object.
|
2011-03-18 20:35:07 +00:00
|
|
|
void DetachGlobal(Handle<Context> env);
|
Split window support from V8.
Here is a description of the background and design of split window in Chrome and V8:
https://docs.google.com/a/google.com/Doc?id=chhjkpg_47fwddxbfr
This change list splits the window object into two parts: 1) an inner window object used as the global object of contexts; 2) an outer window object exposed to JavaScript and accessible by the name 'window'. Firefox did it awhile ago, here are some discussions: https://wiki.mozilla.org/Gecko:SplitWindow. One additional benefit of splitting window in Chrome is that accessing global variables don't need security checks anymore, it can improve applications that use many global variables.
V8 support of split window:
There are a small number of changes on V8 api to support split window:
Security context is removed from V8, so does related API functions;
A global object can be detached from its context and reused by a new context;
Access checks on an object template can be turned on/off by default;
An object can turn on its access checks later;
V8 has a new object type, ApiGlobalObject, which is the outer window object type. The existing JSGlobalObject becomes the inner window object type. Security checks are moved from JSGlobalObject to ApiGlobalObject. ApiGlobalObject is the one exposed to JavaScript, it is accessible through Context::Global(). ApiGlobalObject's prototype is set to JSGlobalObject so that property lookups are forwarded to JSGlobalObject. ApiGlobalObject forwards all other property access requests to JSGlobalObject, such as SetProperty, DeleteProperty, etc.
Security token is moved to a global context, and ApiGlobalObject has a reference to its global context. JSGlobalObject has a reference to its global context as well. When accessing properties on a global object in JavaScript, the domain security check is performed by comparing the security token of the lexical context (Top::global_context()) to the token of global object's context. The check is only needed when the receiver is a window object, such as 'window.document'. Accessing global variables, such as 'var foo = 3; foo' does not need checks because the receiver is the inner window object.
When an outer window is detached from its global context (when a frame navigates away from a page), it is completely detached from the inner window. A new context is created for the new page, and the outer global object is reused. At this point, the access check on the DOMWindow wrapper of the old context is turned on. The code in old context is still able to access DOMWindow properties, but it has to go through domain security checks.
It is debatable on how to implement the outer window object. Currently each property access function has to check if the receiver is ApiGlobalObject type. This approach might be error-prone that one may forget to check the receiver when adding new functions. It is unlikely a performance issue because accessing global variables are more common than 'window.foo' style coding.
I am still working on the ARM port, and I'd like to hear comments and suggestions on the best way to support it in V8.
Review URL: http://codereview.chromium.org/7366
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@540 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2008-10-21 19:07:58 +00:00
|
|
|
|
2009-01-15 19:08:34 +00:00
|
|
|
// Traverses the pointers for memory management.
|
2017-04-25 13:32:18 +00:00
|
|
|
void Iterate(RootVisitor* v);
|
2008-07-03 15:10:15 +00:00
|
|
|
|
2010-03-23 11:40:38 +00:00
|
|
|
// Accessor for the native scripts source code.
|
2017-04-11 05:46:46 +00:00
|
|
|
Handle<String> GetNativeSource(NativeType type, int index);
|
2008-07-03 15:10:15 +00:00
|
|
|
|
2009-01-15 19:08:34 +00:00
|
|
|
// Tells whether bootstrapping is active.
|
2011-03-18 20:35:07 +00:00
|
|
|
bool IsActive() const { return nesting_ != 0; }
|
2008-07-03 15:10:15 +00:00
|
|
|
|
2009-01-26 18:09:46 +00:00
|
|
|
// Support for thread preemption.
|
2011-05-23 12:59:02 +00:00
|
|
|
static int ArchiveSpacePerThread();
|
2011-03-18 20:35:07 +00:00
|
|
|
char* ArchiveState(char* to);
|
|
|
|
char* RestoreState(char* from);
|
|
|
|
void FreeThreadResources();
|
2009-12-11 10:40:01 +00:00
|
|
|
|
2010-03-23 11:40:38 +00:00
|
|
|
// Used for new context creation.
|
2012-08-17 09:03:08 +00:00
|
|
|
bool InstallExtensions(Handle<Context> native_context,
|
2011-03-18 20:35:07 +00:00
|
|
|
v8::ExtensionConfiguration* extensions);
|
|
|
|
|
|
|
|
SourceCodeCache* extensions_cache() { return &extensions_cache_; }
|
|
|
|
|
2015-07-13 09:45:43 +00:00
|
|
|
static bool CompileNative(Isolate* isolate, Vector<const char> name,
|
2015-11-02 13:04:20 +00:00
|
|
|
Handle<String> source, int argc,
|
2016-02-05 12:33:20 +00:00
|
|
|
Handle<Object> argv[], NativesFlag natives_flag);
|
2015-07-13 09:45:43 +00:00
|
|
|
static bool CompileBuiltin(Isolate* isolate, int index);
|
|
|
|
static bool CompileExtraBuiltin(Isolate* isolate, int index);
|
2015-08-20 00:01:07 +00:00
|
|
|
static bool CompileExperimentalExtraBuiltin(Isolate* isolate, int index);
|
2015-07-13 09:45:43 +00:00
|
|
|
|
2015-08-28 10:22:31 +00:00
|
|
|
static void ExportFromRuntime(Isolate* isolate, Handle<JSObject> container);
|
2015-08-14 12:34:45 +00:00
|
|
|
|
2011-03-18 20:35:07 +00:00
|
|
|
private:
|
2013-02-15 09:27:10 +00:00
|
|
|
Isolate* isolate_;
|
2011-03-18 20:35:07 +00:00
|
|
|
typedef int NestingCounterType;
|
|
|
|
NestingCounterType nesting_;
|
|
|
|
SourceCodeCache extensions_cache_;
|
|
|
|
|
|
|
|
friend class BootstrapperActive;
|
|
|
|
friend class Isolate;
|
|
|
|
friend class NativesExternalStringResource;
|
|
|
|
|
2013-02-15 09:27:10 +00:00
|
|
|
explicit Bootstrapper(Isolate* isolate);
|
2011-03-18 20:35:07 +00:00
|
|
|
|
2014-01-17 10:52:00 +00:00
|
|
|
static v8::Extension* free_buffer_extension_;
|
|
|
|
static v8::Extension* gc_extension_;
|
|
|
|
static v8::Extension* externalize_string_extension_;
|
|
|
|
static v8::Extension* statistics_extension_;
|
|
|
|
static v8::Extension* trigger_failure_extension_;
|
2016-04-27 11:10:41 +00:00
|
|
|
static v8::Extension* ignition_statistics_extension_;
|
2014-01-17 10:52:00 +00:00
|
|
|
|
2011-03-18 20:35:07 +00:00
|
|
|
DISALLOW_COPY_AND_ASSIGN(Bootstrapper);
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2015-04-20 13:08:11 +00:00
|
|
|
class BootstrapperActive final BASE_EMBEDDED {
|
2011-03-18 20:35:07 +00:00
|
|
|
public:
|
2013-02-15 09:27:10 +00:00
|
|
|
explicit BootstrapperActive(Bootstrapper* bootstrapper)
|
|
|
|
: bootstrapper_(bootstrapper) {
|
|
|
|
++bootstrapper_->nesting_;
|
2011-03-18 20:35:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
~BootstrapperActive() {
|
2013-02-15 09:27:10 +00:00
|
|
|
--bootstrapper_->nesting_;
|
2011-03-18 20:35:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2013-02-15 09:27:10 +00:00
|
|
|
Bootstrapper* bootstrapper_;
|
|
|
|
|
2011-03-18 20:35:07 +00:00
|
|
|
DISALLOW_COPY_AND_ASSIGN(BootstrapperActive);
|
2008-07-03 15:10:15 +00:00
|
|
|
};
|
|
|
|
|
2015-09-30 13:46:56 +00:00
|
|
|
} // namespace internal
|
|
|
|
} // namespace v8
|
2008-07-03 15:10:15 +00:00
|
|
|
|
|
|
|
#endif // V8_BOOTSTRAPPER_H_
|