1 // Copyright 2006-2008 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are
6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above
9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided
11 // with the distribution.
12 // * Neither the name of Google Inc. nor the names of its
13 // contributors may be used to endorse or promote products derived
14 // from this software without specific prior written permission.
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 #ifndef V8_BOOTSTRAPPER_H_
30 #define V8_BOOTSTRAPPER_H_
32 #include "allocation.h"
38 // A SourceCodeCache uses a FixedArray to store pairs of
39 // (AsciiString*, JSFunction*), mapping names of native code files
40 // (runtime.js, etc.) to precompiled functions. Instead of mapping
41 // names to functions it might make sense to let the JS2C tool
42 // generate an index for each native JS file.
43 class SourceCodeCache BASE_EMBEDDED {
45 explicit SourceCodeCache(Script::Type type): type_(type), cache_(NULL) { }
47 void Initialize(bool create_heap_objects) {
48 cache_ = create_heap_objects ? HEAP->empty_fixed_array() : NULL;
51 void Iterate(ObjectVisitor* v) {
52 v->VisitPointer(BitCast<Object**, FixedArray**>(&cache_));
55 bool Lookup(Vector<const char> name, Handle<SharedFunctionInfo>* handle) {
56 for (int i = 0; i < cache_->length(); i+=2) {
57 SeqAsciiString* str = SeqAsciiString::cast(cache_->get(i));
58 if (str->IsEqualTo(name)) {
59 *handle = Handle<SharedFunctionInfo>(
60 SharedFunctionInfo::cast(cache_->get(i + 1)));
67 void Add(Vector<const char> name, Handle<SharedFunctionInfo> shared) {
69 int length = cache_->length();
70 Handle<FixedArray> new_array =
71 FACTORY->NewFixedArray(length + 2, TENURED);
72 cache_->CopyTo(0, *new_array, 0, cache_->length());
74 Handle<String> str = FACTORY->NewStringFromAscii(name, TENURED);
75 cache_->set(length, *str);
76 cache_->set(length + 1, *shared);
77 Script::cast(shared->script())->set_type(Smi::FromInt(type_));
83 DISALLOW_COPY_AND_ASSIGN(SourceCodeCache);
87 // The Boostrapper is the public interface for creating a JavaScript global
91 // Requires: Heap::Setup has been called.
92 void Initialize(bool create_heap_objects);
95 // Creates a JavaScript Global Context with initial object graph.
96 // The returned value is a global handle casted to V8Environment*.
97 Handle<Context> CreateEnvironment(
99 Handle<Object> global_object,
100 v8::Handle<v8::ObjectTemplate> global_template,
101 v8::ExtensionConfiguration* extensions);
103 // Detach the environment from its outer global object.
104 void DetachGlobal(Handle<Context> env);
106 // Reattach an outer global object to an environment.
107 void ReattachGlobal(Handle<Context> env, Handle<Object> global_object);
109 // Traverses the pointers for memory management.
110 void Iterate(ObjectVisitor* v);
112 // Accessor for the native scripts source code.
113 Handle<String> NativesSourceLookup(int index);
115 // Tells whether bootstrapping is active.
116 bool IsActive() const { return nesting_ != 0; }
118 // Support for thread preemption.
119 static int ArchiveSpacePerThread();
120 char* ArchiveState(char* to);
121 char* RestoreState(char* from);
122 void FreeThreadResources();
124 // This will allocate a char array that is deleted when V8 is shut down.
125 // It should only be used for strictly finite allocations.
126 char* AllocateAutoDeletedArray(int bytes);
128 // Used for new context creation.
129 bool InstallExtensions(Handle<Context> global_context,
130 v8::ExtensionConfiguration* extensions);
132 SourceCodeCache* extensions_cache() { return &extensions_cache_; }
135 typedef int NestingCounterType;
136 NestingCounterType nesting_;
137 SourceCodeCache extensions_cache_;
138 // This is for delete, not delete[].
139 List<char*>* delete_these_non_arrays_on_tear_down_;
140 // This is for delete[]
141 List<char*>* delete_these_arrays_on_tear_down_;
143 friend class BootstrapperActive;
144 friend class Isolate;
145 friend class NativesExternalStringResource;
149 DISALLOW_COPY_AND_ASSIGN(Bootstrapper);
153 class BootstrapperActive BASE_EMBEDDED {
155 BootstrapperActive() {
156 ++Isolate::Current()->bootstrapper()->nesting_;
159 ~BootstrapperActive() {
160 --Isolate::Current()->bootstrapper()->nesting_;
164 DISALLOW_COPY_AND_ASSIGN(BootstrapperActive);
168 class NativesExternalStringResource
169 : public v8::String::ExternalAsciiStringResource {
171 NativesExternalStringResource(Bootstrapper* bootstrapper,
175 const char* data() const {
179 size_t length() const {
187 }} // namespace v8::internal
189 #endif // V8_BOOTSTRAPPER_H_