1 // Copyright 2012 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.
33 #include "../include/v8-testing.h"
42 // Constants used in the implementation of the API. The most natural thing
43 // would usually be to place these with the classes that use them, but
44 // we want to keep them out of v8.h because it is an externally
49 FUNCTION_TEMPLATE = 0,
55 // Utilities for working with neander-objects, primitive
56 // env-independent JSObjects used by the api.
59 explicit NeanderObject(int size);
60 explicit inline NeanderObject(v8::internal::Handle<v8::internal::Object> obj);
61 explicit inline NeanderObject(v8::internal::Object* obj);
62 inline v8::internal::Object* get(int index);
63 inline void set(int index, v8::internal::Object* value);
64 inline v8::internal::Handle<v8::internal::JSObject> value() { return value_; }
67 v8::internal::Handle<v8::internal::JSObject> value_;
71 // Utilities for working with neander-arrays, a simple extensible
72 // array abstraction built on neander-objects.
76 explicit inline NeanderArray(v8::internal::Handle<v8::internal::Object> obj);
77 inline v8::internal::Handle<v8::internal::JSObject> value() {
81 void add(v8::internal::Handle<v8::internal::Object> value);
85 v8::internal::Object* get(int index);
86 // Change the value at an index to undefined value. If the index is
87 // out of bounds, the request is ignored. Returns the old value.
88 void set(int index, v8::internal::Object* value);
94 NeanderObject::NeanderObject(v8::internal::Handle<v8::internal::Object> obj)
95 : value_(v8::internal::Handle<v8::internal::JSObject>::cast(obj)) { }
98 NeanderObject::NeanderObject(v8::internal::Object* obj)
99 : value_(v8::internal::Handle<v8::internal::JSObject>(
100 v8::internal::JSObject::cast(obj))) { }
103 NeanderArray::NeanderArray(v8::internal::Handle<v8::internal::Object> obj)
107 v8::internal::Object* NeanderObject::get(int offset) {
108 ASSERT(value()->HasFastObjectElements());
109 return v8::internal::FixedArray::cast(value()->elements())->get(offset);
113 void NeanderObject::set(int offset, v8::internal::Object* value) {
114 ASSERT(value_->HasFastObjectElements());
115 v8::internal::FixedArray::cast(value_->elements())->set(offset, value);
119 template <typename T> inline T ToCData(v8::internal::Object* obj) {
120 STATIC_ASSERT(sizeof(T) == sizeof(v8::internal::Address));
121 return reinterpret_cast<T>(
122 reinterpret_cast<intptr_t>(
123 v8::internal::Foreign::cast(obj)->foreign_address()));
127 template <typename T>
128 inline v8::internal::Handle<v8::internal::Object> FromCData(T obj) {
129 STATIC_ASSERT(sizeof(T) == sizeof(v8::internal::Address));
130 return FACTORY->NewForeign(
131 reinterpret_cast<v8::internal::Address>(reinterpret_cast<intptr_t>(obj)));
137 explicit ApiFunction(v8::internal::Address addr) : addr_(addr) { }
138 v8::internal::Address address() { return addr_; }
140 v8::internal::Address addr_;
145 class RegisteredExtension {
147 explicit RegisteredExtension(Extension* extension);
148 static void Register(RegisteredExtension* that);
149 static void UnregisterAll();
150 Extension* extension() { return extension_; }
151 RegisteredExtension* next() { return next_; }
152 RegisteredExtension* next_auto() { return next_auto_; }
153 static RegisteredExtension* first_extension() { return first_extension_; }
155 Extension* extension_;
156 RegisteredExtension* next_;
157 RegisteredExtension* next_auto_;
158 static RegisteredExtension* first_extension_;
164 static bool ReportApiFailure(const char* location, const char* message);
166 static Local<FunctionTemplate> ToFunctionTemplate(NeanderObject obj);
167 static Local<ObjectTemplate> ToObjectTemplate(NeanderObject obj);
169 static inline Local<Context> ToLocal(
170 v8::internal::Handle<v8::internal::Context> obj);
171 static inline Local<Value> ToLocal(
172 v8::internal::Handle<v8::internal::Object> obj);
173 static inline Local<Function> ToLocal(
174 v8::internal::Handle<v8::internal::JSFunction> obj);
175 static inline Local<String> ToLocal(
176 v8::internal::Handle<v8::internal::String> obj);
177 static inline Local<RegExp> ToLocal(
178 v8::internal::Handle<v8::internal::JSRegExp> obj);
179 static inline Local<Object> ToLocal(
180 v8::internal::Handle<v8::internal::JSObject> obj);
181 static inline Local<Array> ToLocal(
182 v8::internal::Handle<v8::internal::JSArray> obj);
183 static inline Local<External> ToLocal(
184 v8::internal::Handle<v8::internal::Foreign> obj);
185 static inline Local<Message> MessageToLocal(
186 v8::internal::Handle<v8::internal::Object> obj);
187 static inline Local<StackTrace> StackTraceToLocal(
188 v8::internal::Handle<v8::internal::JSArray> obj);
189 static inline Local<StackFrame> StackFrameToLocal(
190 v8::internal::Handle<v8::internal::JSObject> obj);
191 static inline Local<Number> NumberToLocal(
192 v8::internal::Handle<v8::internal::Object> obj);
193 static inline Local<Integer> IntegerToLocal(
194 v8::internal::Handle<v8::internal::Object> obj);
195 static inline Local<Uint32> Uint32ToLocal(
196 v8::internal::Handle<v8::internal::Object> obj);
197 static inline Local<FunctionTemplate> ToLocal(
198 v8::internal::Handle<v8::internal::FunctionTemplateInfo> obj);
199 static inline Local<ObjectTemplate> ToLocal(
200 v8::internal::Handle<v8::internal::ObjectTemplateInfo> obj);
201 static inline Local<Signature> ToLocal(
202 v8::internal::Handle<v8::internal::SignatureInfo> obj);
203 static inline Local<TypeSwitch> ToLocal(
204 v8::internal::Handle<v8::internal::TypeSwitchInfo> obj);
206 static inline v8::internal::Handle<v8::internal::TemplateInfo>
207 OpenHandle(const Template* that);
208 static inline v8::internal::Handle<v8::internal::FunctionTemplateInfo>
209 OpenHandle(const FunctionTemplate* that);
210 static inline v8::internal::Handle<v8::internal::ObjectTemplateInfo>
211 OpenHandle(const ObjectTemplate* that);
212 static inline v8::internal::Handle<v8::internal::Object>
213 OpenHandle(const Data* data);
214 static inline v8::internal::Handle<v8::internal::JSRegExp>
215 OpenHandle(const RegExp* data);
216 static inline v8::internal::Handle<v8::internal::JSObject>
217 OpenHandle(const v8::Object* data);
218 static inline v8::internal::Handle<v8::internal::JSArray>
219 OpenHandle(const v8::Array* data);
220 static inline v8::internal::Handle<v8::internal::String>
221 OpenHandle(const String* data);
222 static inline v8::internal::Handle<v8::internal::Object>
223 OpenHandle(const Script* data);
224 static inline v8::internal::Handle<v8::internal::JSFunction>
225 OpenHandle(const Function* data);
226 static inline v8::internal::Handle<v8::internal::JSObject>
227 OpenHandle(const Message* message);
228 static inline v8::internal::Handle<v8::internal::JSArray>
229 OpenHandle(const StackTrace* stack_trace);
230 static inline v8::internal::Handle<v8::internal::JSObject>
231 OpenHandle(const StackFrame* stack_frame);
232 static inline v8::internal::Handle<v8::internal::Context>
233 OpenHandle(const v8::Context* context);
234 static inline v8::internal::Handle<v8::internal::SignatureInfo>
235 OpenHandle(const v8::Signature* sig);
236 static inline v8::internal::Handle<v8::internal::TypeSwitchInfo>
237 OpenHandle(const v8::TypeSwitch* that);
238 static inline v8::internal::Handle<v8::internal::Foreign>
239 OpenHandle(const v8::External* that);
244 inline T* ToApi(v8::internal::Handle<v8::internal::Object> obj) {
245 return reinterpret_cast<T*>(obj.location());
250 v8::internal::Handle<T> v8::internal::Handle<T>::EscapeFrom(
251 v8::HandleScope* scope) {
252 v8::internal::Handle<T> handle;
256 return Utils::OpenHandle(*scope->Close(Utils::ToLocal(handle)));
260 // Implementations of ToLocal
262 #define MAKE_TO_LOCAL(Name, From, To) \
263 Local<v8::To> Utils::Name(v8::internal::Handle<v8::internal::From> obj) { \
264 ASSERT(obj.is_null() || !obj->IsTheHole()); \
265 return Local<To>(reinterpret_cast<To*>(obj.location())); \
268 MAKE_TO_LOCAL(ToLocal, Context, Context)
269 MAKE_TO_LOCAL(ToLocal, Object, Value)
270 MAKE_TO_LOCAL(ToLocal, JSFunction, Function)
271 MAKE_TO_LOCAL(ToLocal, String, String)
272 MAKE_TO_LOCAL(ToLocal, JSRegExp, RegExp)
273 MAKE_TO_LOCAL(ToLocal, JSObject, Object)
274 MAKE_TO_LOCAL(ToLocal, JSArray, Array)
275 MAKE_TO_LOCAL(ToLocal, Foreign, External)
276 MAKE_TO_LOCAL(ToLocal, FunctionTemplateInfo, FunctionTemplate)
277 MAKE_TO_LOCAL(ToLocal, ObjectTemplateInfo, ObjectTemplate)
278 MAKE_TO_LOCAL(ToLocal, SignatureInfo, Signature)
279 MAKE_TO_LOCAL(ToLocal, TypeSwitchInfo, TypeSwitch)
280 MAKE_TO_LOCAL(MessageToLocal, Object, Message)
281 MAKE_TO_LOCAL(StackTraceToLocal, JSArray, StackTrace)
282 MAKE_TO_LOCAL(StackFrameToLocal, JSObject, StackFrame)
283 MAKE_TO_LOCAL(NumberToLocal, Object, Number)
284 MAKE_TO_LOCAL(IntegerToLocal, Object, Integer)
285 MAKE_TO_LOCAL(Uint32ToLocal, Object, Uint32)
290 // Implementations of OpenHandle
292 #define MAKE_OPEN_HANDLE(From, To) \
293 v8::internal::Handle<v8::internal::To> Utils::OpenHandle(\
294 const v8::From* that) { \
295 return v8::internal::Handle<v8::internal::To>( \
296 reinterpret_cast<v8::internal::To**>(const_cast<v8::From*>(that))); \
299 MAKE_OPEN_HANDLE(Template, TemplateInfo)
300 MAKE_OPEN_HANDLE(FunctionTemplate, FunctionTemplateInfo)
301 MAKE_OPEN_HANDLE(ObjectTemplate, ObjectTemplateInfo)
302 MAKE_OPEN_HANDLE(Signature, SignatureInfo)
303 MAKE_OPEN_HANDLE(TypeSwitch, TypeSwitchInfo)
304 MAKE_OPEN_HANDLE(Data, Object)
305 MAKE_OPEN_HANDLE(RegExp, JSRegExp)
306 MAKE_OPEN_HANDLE(Object, JSObject)
307 MAKE_OPEN_HANDLE(Array, JSArray)
308 MAKE_OPEN_HANDLE(String, String)
309 MAKE_OPEN_HANDLE(Script, Object)
310 MAKE_OPEN_HANDLE(Function, JSFunction)
311 MAKE_OPEN_HANDLE(Message, JSObject)
312 MAKE_OPEN_HANDLE(Context, Context)
313 MAKE_OPEN_HANDLE(External, Foreign)
314 MAKE_OPEN_HANDLE(StackTrace, JSArray)
315 MAKE_OPEN_HANDLE(StackFrame, JSObject)
317 #undef MAKE_OPEN_HANDLE
322 // Tracks string usage to help make better decisions when
323 // externalizing strings.
325 // Implementation note: internally this class only tracks fresh
326 // strings and keeps a single use counter for them.
327 class StringTracker {
329 // Records that the given string's characters were copied to some
330 // external buffer. If this happens often we should honor
331 // externalization requests for the string.
332 void RecordWrite(Handle<String> string) {
333 Address address = reinterpret_cast<Address>(*string);
334 Address top = isolate_->heap()->NewSpaceTop();
335 if (IsFreshString(address, top)) {
336 IncrementUseCount(top);
340 // Estimates freshness and use frequency of the given string based
341 // on how close it is to the new space top and the recorded usage
343 inline bool IsFreshUnusedString(Handle<String> string) {
344 Address address = reinterpret_cast<Address>(*string);
345 Address top = isolate_->heap()->NewSpaceTop();
346 return IsFreshString(address, top) && IsUseCountLow(top);
350 StringTracker() : use_count_(0), last_top_(NULL), isolate_(NULL) { }
352 static inline bool IsFreshString(Address string, Address top) {
353 return top - kFreshnessLimit <= string && string <= top;
356 inline bool IsUseCountLow(Address top) {
357 if (last_top_ != top) return true;
358 return use_count_ < kUseLimit;
361 inline void IncrementUseCount(Address top) {
362 if (last_top_ != top) {
369 // Single use counter shared by all fresh strings.
372 // Last new space top when the use count above was valid.
377 // How close to the new space top a fresh string has to be.
378 static const int kFreshnessLimit = 1024;
380 // The number of uses required to consider a string useful.
381 static const int kUseLimit = 32;
383 friend class Isolate;
385 DISALLOW_COPY_AND_ASSIGN(StringTracker);
389 // This class is here in order to be able to declare it a friend of
390 // HandleScope. Moving these methods to be members of HandleScope would be
391 // neat in some ways, but it would expose internal implementation details in
392 // our public header file, which is undesirable.
394 // An isolate has a single instance of this class to hold the current thread's
395 // data. In multithreaded V8 programs this data is copied in and out of storage
396 // so that the currently executing thread always has its own copy of this
398 class HandleScopeImplementer {
400 explicit HandleScopeImplementer(Isolate* isolate)
403 entered_contexts_(0),
408 ~HandleScopeImplementer() {
412 // Threading support for handle data.
413 static int ArchiveSpacePerThread();
414 char* RestoreThread(char* from);
415 char* ArchiveThread(char* to);
416 void FreeThreadResources();
418 // Garbage collection support.
419 void Iterate(v8::internal::ObjectVisitor* v);
420 static char* Iterate(v8::internal::ObjectVisitor* v, char* data);
423 inline internal::Object** GetSpareOrNewBlock();
424 inline void DeleteExtensions(internal::Object** prev_limit);
426 inline void IncrementCallDepth() {call_depth_++;}
427 inline void DecrementCallDepth() {call_depth_--;}
428 inline bool CallDepthIsZero() { return call_depth_ == 0; }
430 inline void EnterContext(Handle<Object> context);
431 inline bool LeaveLastContext();
433 // Returns the last entered context or an empty handle if no
434 // contexts have been entered.
435 inline Handle<Object> LastEnteredContext();
437 inline void SaveContext(Context* context);
438 inline Context* RestoreContext();
439 inline bool HasSavedContexts();
441 inline List<internal::Object**>* blocks() { return &blocks_; }
444 void ResetAfterArchive() {
445 blocks_.Initialize(0);
446 entered_contexts_.Initialize(0);
447 saved_contexts_.Initialize(0);
453 ASSERT(blocks_.length() == 0);
454 ASSERT(entered_contexts_.length() == 0);
455 ASSERT(saved_contexts_.length() == 0);
457 entered_contexts_.Free();
458 saved_contexts_.Free();
459 if (spare_ != NULL) {
463 ASSERT(call_depth_ == 0);
467 List<internal::Object**> blocks_;
468 // Used as a stack to keep track of entered contexts.
469 List<Handle<Object> > entered_contexts_;
470 // Used as a stack to keep track of saved contexts.
471 List<Context*> saved_contexts_;
474 // This is only used for threading support.
475 v8::ImplementationUtilities::HandleScopeData handle_scope_data_;
477 void IterateThis(ObjectVisitor* v);
478 char* RestoreThreadHelper(char* from);
479 char* ArchiveThreadHelper(char* to);
481 DISALLOW_COPY_AND_ASSIGN(HandleScopeImplementer);
485 const int kHandleBlockSize = v8::internal::KB - 2; // fit in one page
488 void HandleScopeImplementer::SaveContext(Context* context) {
489 saved_contexts_.Add(context);
493 Context* HandleScopeImplementer::RestoreContext() {
494 return saved_contexts_.RemoveLast();
498 bool HandleScopeImplementer::HasSavedContexts() {
499 return !saved_contexts_.is_empty();
503 void HandleScopeImplementer::EnterContext(Handle<Object> context) {
504 entered_contexts_.Add(context);
508 bool HandleScopeImplementer::LeaveLastContext() {
509 if (entered_contexts_.is_empty()) return false;
510 entered_contexts_.RemoveLast();
515 Handle<Object> HandleScopeImplementer::LastEnteredContext() {
516 if (entered_contexts_.is_empty()) return Handle<Object>::null();
517 return entered_contexts_.last();
521 // If there's a spare block, use it for growing the current scope.
522 internal::Object** HandleScopeImplementer::GetSpareOrNewBlock() {
523 internal::Object** block = (spare_ != NULL) ?
525 NewArray<internal::Object*>(kHandleBlockSize);
531 void HandleScopeImplementer::DeleteExtensions(internal::Object** prev_limit) {
532 while (!blocks_.is_empty()) {
533 internal::Object** block_start = blocks_.last();
534 internal::Object** block_limit = block_start + kHandleBlockSize;
536 // NoHandleAllocation may make the prev_limit to point inside the block.
537 if (block_start <= prev_limit && prev_limit <= block_limit) break;
539 if (prev_limit == block_limit) break;
542 blocks_.RemoveLast();
544 v8::ImplementationUtilities::ZapHandleRange(block_start, block_limit);
546 if (spare_ != NULL) {
549 spare_ = block_start;
551 ASSERT((blocks_.is_empty() && prev_limit == NULL) ||
552 (!blocks_.is_empty() && prev_limit != NULL));
558 static v8::Testing::StressType stress_type() { return stress_type_; }
559 static void set_stress_type(v8::Testing::StressType stress_type) {
560 stress_type_ = stress_type;
564 static v8::Testing::StressType stress_type_;
567 } } // namespace v8::internal