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
34namespace v8 {
35namespace 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.
43class SourceCodeCache BASE_EMBEDDED {
44 public:
45  explicit SourceCodeCache(Script::Type type): type_(type), cache_(NULL) { }
46
47  void Initialize(bool create_heap_objects) {
48    cache_ = create_heap_objects ? HEAP->empty_fixed_array() : NULL;
49  }
50
51  void Iterate(ObjectVisitor* v) {
52    v->VisitPointer(BitCast<Object**, FixedArray**>(&cache_));
53  }
54
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
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.
89class 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.
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
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
153class BootstrapperActive BASE_EMBEDDED {
154 public:
155  BootstrapperActive() {
156    ++Isolate::Current()->bootstrapper()->nesting_;
157  }
158
159  ~BootstrapperActive() {
160    --Isolate::Current()->bootstrapper()->nesting_;
161  }
162
163 private:
164  DISALLOW_COPY_AND_ASSIGN(BootstrapperActive);
165};
166
167
168class NativesExternalStringResource
169    : public v8::String::ExternalAsciiStringResource {
170 public:
171  NativesExternalStringResource(Bootstrapper* bootstrapper,
172                                const char* source,
173                                size_t length);
174
175  const char* data() const {
176    return data_;
177  }
178
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