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 4 // met: 5 // 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. 15 // 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. 27 28 29 #ifndef V8_BOOTSTRAPPER_H_ 30 #define V8_BOOTSTRAPPER_H_ 31 32 #include "allocation.h" 33 34 namespace v8 { 35 namespace internal { 36 37 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 { 44 public: SourceCodeCache(Script::Type type)45 explicit SourceCodeCache(Script::Type type): type_(type), cache_(NULL) { } 46 Initialize(bool create_heap_objects)47 void Initialize(bool create_heap_objects) { 48 cache_ = create_heap_objects ? HEAP->empty_fixed_array() : NULL; 49 } 50 Iterate(ObjectVisitor * v)51 void Iterate(ObjectVisitor* v) { 52 v->VisitPointer(BitCast<Object**, FixedArray**>(&cache_)); 53 } 54 Lookup(Vector<const char> name,Handle<SharedFunctionInfo> * handle)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))); 61 return true; 62 } 63 } 64 return false; 65 } 66 Add(Vector<const char> name,Handle<SharedFunctionInfo> shared)67 void Add(Vector<const char> name, Handle<SharedFunctionInfo> shared) { 68 HandleScope scope; 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()); 73 cache_ = *new_array; 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_)); 78 } 79 80 private: 81 Script::Type type_; 82 FixedArray* cache_; 83 DISALLOW_COPY_AND_ASSIGN(SourceCodeCache); 84 }; 85 86 87 // The Boostrapper is the public interface for creating a JavaScript global 88 // context. 89 class Bootstrapper { 90 public: 91 // Requires: Heap::SetUp has been called. 92 void Initialize(bool create_heap_objects); 93 void TearDown(); 94 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( 98 Isolate* isolate, 99 Handle<Object> global_object, 100 v8::Handle<v8::ObjectTemplate> global_template, 101 v8::ExtensionConfiguration* extensions); 102 103 // Detach the environment from its outer global object. 104 void DetachGlobal(Handle<Context> env); 105 106 // Reattach an outer global object to an environment. 107 void ReattachGlobal(Handle<Context> env, Handle<Object> global_object); 108 109 // Traverses the pointers for memory management. 110 void Iterate(ObjectVisitor* v); 111 112 // Accessor for the native scripts source code. 113 Handle<String> NativesSourceLookup(int index); 114 115 // Tells whether bootstrapping is active. IsActive()116 bool IsActive() const { return nesting_ != 0; } 117 118 // Support for thread preemption. 119 static int ArchiveSpacePerThread(); 120 char* ArchiveState(char* to); 121 char* RestoreState(char* from); 122 void FreeThreadResources(); 123 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); 127 128 // Used for new context creation. 129 bool InstallExtensions(Handle<Context> global_context, 130 v8::ExtensionConfiguration* extensions); 131 extensions_cache()132 SourceCodeCache* extensions_cache() { return &extensions_cache_; } 133 134 private: 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_; 142 143 friend class BootstrapperActive; 144 friend class Isolate; 145 friend class NativesExternalStringResource; 146 147 Bootstrapper(); 148 149 DISALLOW_COPY_AND_ASSIGN(Bootstrapper); 150 }; 151 152 153 class BootstrapperActive BASE_EMBEDDED { 154 public: BootstrapperActive()155 BootstrapperActive() { 156 ++Isolate::Current()->bootstrapper()->nesting_; 157 } 158 ~BootstrapperActive()159 ~BootstrapperActive() { 160 --Isolate::Current()->bootstrapper()->nesting_; 161 } 162 163 private: 164 DISALLOW_COPY_AND_ASSIGN(BootstrapperActive); 165 }; 166 167 168 class NativesExternalStringResource 169 : public v8::String::ExternalAsciiStringResource { 170 public: 171 NativesExternalStringResource(Bootstrapper* bootstrapper, 172 const char* source, 173 size_t length); 174 data()175 const char* data() const { 176 return data_; 177 } 178 length()179 size_t length() const { 180 return length_; 181 } 182 private: 183 const char* data_; 184 size_t length_; 185 }; 186 187 }} // namespace v8::internal 188 189 #endif // V8_BOOTSTRAPPER_H_ 190