diff options
Diffstat (limited to 'chromium/v8/src/factory.h')
| -rw-r--r-- | chromium/v8/src/factory.h | 488 |
1 files changed, 306 insertions, 182 deletions
diff --git a/chromium/v8/src/factory.h b/chromium/v8/src/factory.h index 92086d4b304..e22ea8d323d 100644 --- a/chromium/v8/src/factory.h +++ b/chromium/v8/src/factory.h @@ -1,50 +1,25 @@ -// Copyright 2012 the V8 project authors. All rights reserved. -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following -// disclaimer in the documentation and/or other materials provided -// with the distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived -// from this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// 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. #ifndef V8_FACTORY_H_ #define V8_FACTORY_H_ -#include "globals.h" -#include "handles.h" -#include "heap.h" +#include "src/isolate.h" namespace v8 { namespace internal { // Interface for handle based allocation. -class Factory { +class Factory V8_FINAL { public: - // Allocate a new boxed value. - Handle<Box> NewBox( - Handle<Object> value, - PretenureFlag pretenure = NOT_TENURED); + Handle<Oddball> NewOddball(Handle<Map> map, + const char* to_string, + Handle<Object> to_number, + byte kind); - // Allocate a new uninitialized fixed array. + // Allocates a fixed array initialized with undefined values. Handle<FixedArray> NewFixedArray( int size, PretenureFlag pretenure = NOT_TENURED); @@ -54,56 +29,56 @@ class Factory { int size, PretenureFlag pretenure = NOT_TENURED); + // Allocates an uninitialized fixed array. It must be filled by the caller. + Handle<FixedArray> NewUninitializedFixedArray(int size); + // Allocate a new uninitialized fixed double array. - Handle<FixedDoubleArray> NewFixedDoubleArray( + // The function returns a pre-allocated empty fixed array for capacity = 0, + // so the return type must be the general fixed array class. + Handle<FixedArrayBase> NewFixedDoubleArray( int size, PretenureFlag pretenure = NOT_TENURED); - Handle<ConstantPoolArray> NewConstantPoolArray( - int number_of_int64_entries, - int number_of_ptr_entries, - int number_of_int32_entries); - - Handle<SeededNumberDictionary> NewSeededNumberDictionary( - int at_least_space_for); - - Handle<UnseededNumberDictionary> NewUnseededNumberDictionary( - int at_least_space_for); + // Allocate a new fixed double array with hole values. + Handle<FixedArrayBase> NewFixedDoubleArrayWithHoles( + int size, + PretenureFlag pretenure = NOT_TENURED); - Handle<NameDictionary> NewNameDictionary(int at_least_space_for); + Handle<ConstantPoolArray> NewConstantPoolArray( + const ConstantPoolArray::NumberOfEntries& small); - Handle<ObjectHashSet> NewObjectHashSet(int at_least_space_for); + Handle<ConstantPoolArray> NewExtendedConstantPoolArray( + const ConstantPoolArray::NumberOfEntries& small, + const ConstantPoolArray::NumberOfEntries& extended); - Handle<ObjectHashTable> NewObjectHashTable( - int at_least_space_for, - MinimumCapacity capacity_option = USE_DEFAULT_MINIMUM_CAPACITY); + Handle<OrderedHashSet> NewOrderedHashSet(); + Handle<OrderedHashMap> NewOrderedHashMap(); - Handle<WeakHashTable> NewWeakHashTable(int at_least_space_for); + // Create a new boxed value. + Handle<Box> NewBox(Handle<Object> value); - Handle<DescriptorArray> NewDescriptorArray(int number_of_descriptors, - int slack = 0); - Handle<DeoptimizationInputData> NewDeoptimizationInputData( - int deopt_entry_count, - PretenureFlag pretenure); - Handle<DeoptimizationOutputData> NewDeoptimizationOutputData( - int deopt_entry_count, - PretenureFlag pretenure); - // Allocates a pre-tenured empty AccessorPair. + // Create a pre-tenured empty AccessorPair. Handle<AccessorPair> NewAccessorPair(); + // Create an empty TypeFeedbackInfo. Handle<TypeFeedbackInfo> NewTypeFeedbackInfo(); + // Finds the internalized copy for string in the string table. + // If not found, a new string is added to the table and returned. Handle<String> InternalizeUtf8String(Vector<const char> str); Handle<String> InternalizeUtf8String(const char* str) { return InternalizeUtf8String(CStrVector(str)); } Handle<String> InternalizeString(Handle<String> str); Handle<String> InternalizeOneByteString(Vector<const uint8_t> str); - Handle<String> InternalizeOneByteString(Handle<SeqOneByteString>, - int from, - int length); + Handle<String> InternalizeOneByteString( + Handle<SeqOneByteString>, int from, int length); + Handle<String> InternalizeTwoByteString(Vector<const uc16> str); + template<class StringTableKey> + Handle<String> InternalizeStringWithKey(StringTableKey* key); + // String creation functions. Most of the string creation functions take // a Heap::PretenureFlag argument to optionally request that they be @@ -127,11 +102,45 @@ class Factory { // two byte. // // ASCII strings are pretenured when used as keys in the SourceCodeCache. - Handle<String> NewStringFromOneByte( + MUST_USE_RESULT MaybeHandle<String> NewStringFromOneByte( Vector<const uint8_t> str, PretenureFlag pretenure = NOT_TENURED); + + template<size_t N> + inline Handle<String> NewStringFromStaticAscii( + const char (&str)[N], + PretenureFlag pretenure = NOT_TENURED) { + ASSERT(N == StrLength(str) + 1); + return NewStringFromOneByte( + STATIC_ASCII_VECTOR(str), pretenure).ToHandleChecked(); + } + + inline Handle<String> NewStringFromAsciiChecked( + const char* str, + PretenureFlag pretenure = NOT_TENURED) { + return NewStringFromOneByte( + OneByteVector(str), pretenure).ToHandleChecked(); + } + + + // Allocates and fully initializes a String. There are two String + // encodings: ASCII and two byte. One should choose between the three string + // allocation functions based on the encoding of the string buffer used to + // initialized the string. + // - ...FromAscii initializes the string from a buffer that is ASCII + // encoded (it does not check that the buffer is ASCII encoded) and the + // result will be ASCII encoded. + // - ...FromUTF8 initializes the string from a buffer that is UTF-8 + // encoded. If the characters are all single-byte characters, the + // result will be ASCII encoded, otherwise it will converted to two + // byte. + // - ...FromTwoByte initializes the string from a buffer that is two-byte + // encoded. If the characters are all single-byte characters, the + // result will be converted to ASCII, otherwise it will be left as + // two-byte. + // TODO(dcarney): remove this function. - inline Handle<String> NewStringFromAscii( + MUST_USE_RESULT inline MaybeHandle<String> NewStringFromAscii( Vector<const char> str, PretenureFlag pretenure = NOT_TENURED) { return NewStringFromOneByte(Vector<const uint8_t>::cast(str), pretenure); @@ -139,49 +148,78 @@ class Factory { // UTF8 strings are pretenured when used for regexp literal patterns and // flags in the parser. - Handle<String> NewStringFromUtf8( + MUST_USE_RESULT MaybeHandle<String> NewStringFromUtf8( Vector<const char> str, PretenureFlag pretenure = NOT_TENURED); - Handle<String> NewStringFromTwoByte( + MUST_USE_RESULT MaybeHandle<String> NewStringFromTwoByte( Vector<const uc16> str, PretenureFlag pretenure = NOT_TENURED); + // Allocates an internalized string in old space based on the character + // stream. + MUST_USE_RESULT Handle<String> NewInternalizedStringFromUtf8( + Vector<const char> str, + int chars, + uint32_t hash_field); + + MUST_USE_RESULT Handle<String> NewOneByteInternalizedString( + Vector<const uint8_t> str, + uint32_t hash_field); + + MUST_USE_RESULT Handle<String> NewTwoByteInternalizedString( + Vector<const uc16> str, + uint32_t hash_field); + + MUST_USE_RESULT Handle<String> NewInternalizedStringImpl( + Handle<String> string, int chars, uint32_t hash_field); + + // Compute the matching internalized string map for a string if possible. + // Empty handle is returned if string is in new space or not flattened. + MUST_USE_RESULT MaybeHandle<Map> InternalizedStringMapForString( + Handle<String> string); + // Allocates and partially initializes an ASCII or TwoByte String. The // characters of the string are uninitialized. Currently used in regexp code // only, where they are pretenured. - Handle<SeqOneByteString> NewRawOneByteString( + MUST_USE_RESULT MaybeHandle<SeqOneByteString> NewRawOneByteString( int length, PretenureFlag pretenure = NOT_TENURED); - Handle<SeqTwoByteString> NewRawTwoByteString( + MUST_USE_RESULT MaybeHandle<SeqTwoByteString> NewRawTwoByteString( int length, PretenureFlag pretenure = NOT_TENURED); + // Creates a single character string where the character has given code. + // A cache is used for ASCII codes. + Handle<String> LookupSingleCharacterStringFromCode(uint32_t code); + // Create a new cons string object which consists of a pair of strings. - Handle<String> NewConsString(Handle<String> first, - Handle<String> second); + MUST_USE_RESULT MaybeHandle<String> NewConsString(Handle<String> left, + Handle<String> right); // Create a new sequential string containing the concatenation of the inputs. Handle<String> NewFlatConcatString(Handle<String> first, Handle<String> second); - // Create a new string object which holds a substring of a string. - Handle<String> NewSubString(Handle<String> str, - int begin, - int end); - // Create a new string object which holds a proper substring of a string. Handle<String> NewProperSubString(Handle<String> str, int begin, int end); + // Create a new string object which holds a substring of a string. + Handle<String> NewSubString(Handle<String> str, int begin, int end) { + if (begin == 0 && end == str->length()) return str; + return NewProperSubString(str, begin, end); + } + // Creates a new external String object. There are two String encodings // in the system: ASCII and two byte. Unlike other String types, it does // not make sense to have a UTF-8 factory function for external strings, - // because we cannot change the underlying buffer. - Handle<String> NewExternalStringFromAscii( + // because we cannot change the underlying buffer. Note that these strings + // are backed by a string resource that resides outside the V8 heap. + MUST_USE_RESULT MaybeHandle<String> NewExternalStringFromAscii( const ExternalAsciiString::Resource* resource); - Handle<String> NewExternalStringFromTwoByte( + MUST_USE_RESULT MaybeHandle<String> NewExternalStringFromTwoByte( const ExternalTwoByteString::Resource* resource); // Create a symbol. @@ -210,20 +248,19 @@ class Factory { // Create a 'with' context. Handle<Context> NewWithContext(Handle<JSFunction> function, Handle<Context> previous, - Handle<JSObject> extension); + Handle<JSReceiver> extension); // Create a block context. Handle<Context> NewBlockContext(Handle<JSFunction> function, Handle<Context> previous, Handle<ScopeInfo> scope_info); - // Return the internalized version of the passed in string. - Handle<String> InternalizedStringFromString(Handle<String> value); - // Allocate a new struct. The struct is pretenured (allocated directly in // the old generation). Handle<Struct> NewStruct(InstanceType type); + Handle<CodeCache> NewCodeCache(); + Handle<AliasedArgumentsEntry> NewAliasedArgumentsEntry( int aliased_context_slot); @@ -252,12 +289,18 @@ class Factory { void* external_pointer, PretenureFlag pretenure = NOT_TENURED); + Handle<FixedTypedArrayBase> NewFixedTypedArray( + int length, + ExternalArrayType array_type, + PretenureFlag pretenure = NOT_TENURED); + Handle<Cell> NewCell(Handle<Object> value); Handle<PropertyCell> NewPropertyCellWithHole(); Handle<PropertyCell> NewPropertyCell(Handle<Object> value); + // Allocate a tenured AllocationSite. It's payload is null. Handle<AllocationSite> NewAllocationSite(); Handle<Map> NewMap( @@ -265,23 +308,25 @@ class Factory { int instance_size, ElementsKind elements_kind = TERMINAL_FAST_ELEMENTS_KIND); + Handle<HeapObject> NewFillerObject(int size, + bool double_align, + AllocationSpace space); + Handle<JSObject> NewFunctionPrototype(Handle<JSFunction> function); - Handle<Map> CopyWithPreallocatedFieldDescriptors(Handle<Map> map); + Handle<JSObject> CopyJSObject(Handle<JSObject> object); - // Copy the map adding more inobject properties if possible without - // overflowing the instance size. - Handle<Map> CopyMap(Handle<Map> map, int extra_inobject_props); - Handle<Map> CopyMap(Handle<Map> map); + Handle<JSObject> CopyJSObjectWithAllocationSite(Handle<JSObject> object, + Handle<AllocationSite> site); - Handle<Map> GetElementsTransitionMap(Handle<JSObject> object, - ElementsKind elements_kind); + Handle<FixedArray> CopyFixedArrayWithMap(Handle<FixedArray> array, + Handle<Map> map); Handle<FixedArray> CopyFixedArray(Handle<FixedArray> array); - Handle<FixedArray> CopySizeFixedArray(Handle<FixedArray> array, - int new_length, - PretenureFlag pretenure = NOT_TENURED); + // This method expects a COW array in new space, and creates a copy + // of it in old space. + Handle<FixedArray> CopyAndTenureFixedCOWArray(Handle<FixedArray> array); Handle<FixedDoubleArray> CopyFixedDoubleArray( Handle<FixedDoubleArray> array); @@ -290,6 +335,7 @@ class Factory { Handle<ConstantPoolArray> array); // Numbers (e.g. literals) are pretenured by the parser. + // The return value may be a smi or a heap number. Handle<Object> NewNumber(double value, PretenureFlag pretenure = NOT_TENURED); @@ -297,15 +343,23 @@ class Factory { PretenureFlag pretenure = NOT_TENURED); Handle<Object> NewNumberFromUint(uint32_t value, PretenureFlag pretenure = NOT_TENURED); - inline Handle<Object> NewNumberFromSize(size_t value, - PretenureFlag pretenure = NOT_TENURED); + Handle<Object> NewNumberFromSize(size_t value, + PretenureFlag pretenure = NOT_TENURED) { + if (Smi::IsValid(static_cast<intptr_t>(value))) { + return Handle<Object>(Smi::FromIntptr(static_cast<intptr_t>(value)), + isolate()); + } + return NewNumber(static_cast<double>(value), pretenure); + } Handle<HeapNumber> NewHeapNumber(double value, PretenureFlag pretenure = NOT_TENURED); // These objects are used by the api to create env-independent data // structures in the heap. - Handle<JSObject> NewNeanderObject(); + inline Handle<JSObject> NewNeanderObject() { + return NewJSObjectFromMap(neander_map()); + } Handle<JSObject> NewArgumentsObject(Handle<Object> callee, int length); @@ -313,39 +367,72 @@ class Factory { // runtime. Handle<JSObject> NewJSObject(Handle<JSFunction> constructor, PretenureFlag pretenure = NOT_TENURED); + // JSObject that should have a memento pointing to the allocation site. + Handle<JSObject> NewJSObjectWithMemento(Handle<JSFunction> constructor, + Handle<AllocationSite> site); // Global objects are pretenured and initialized based on a constructor. Handle<GlobalObject> NewGlobalObject(Handle<JSFunction> constructor); // JS objects are pretenured when allocated by the bootstrapper and // runtime. - Handle<JSObject> NewJSObjectFromMap(Handle<Map> map, - PretenureFlag pretenure = NOT_TENURED, - bool allocate_properties = true); - - Handle<JSObject> NewJSObjectFromMapForDeoptimizer( - Handle<Map> map, PretenureFlag pretenure = NOT_TENURED); + Handle<JSObject> NewJSObjectFromMap( + Handle<Map> map, + PretenureFlag pretenure = NOT_TENURED, + bool allocate_properties = true, + Handle<AllocationSite> allocation_site = Handle<AllocationSite>::null()); // JS modules are pretenured. Handle<JSModule> NewJSModule(Handle<Context> context, Handle<ScopeInfo> scope_info); // JS arrays are pretenured when allocated by the parser. + + // Create a JSArray with no elements. + Handle<JSArray> NewJSArray( + ElementsKind elements_kind, + PretenureFlag pretenure = NOT_TENURED); + + // Create a JSArray with a specified length and elements initialized + // according to the specified mode. Handle<JSArray> NewJSArray( + ElementsKind elements_kind, + int length, int capacity, - ElementsKind elements_kind = TERMINAL_FAST_ELEMENTS_KIND, + ArrayStorageAllocationMode mode = INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE, PretenureFlag pretenure = NOT_TENURED); + Handle<JSArray> NewJSArray( + int capacity, + ElementsKind elements_kind = TERMINAL_FAST_ELEMENTS_KIND, + PretenureFlag pretenure = NOT_TENURED) { + if (capacity != 0) { + elements_kind = GetHoleyElementsKind(elements_kind); + } + return NewJSArray(elements_kind, 0, capacity, + INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE, pretenure); + } + + // Create a JSArray with the given elements. Handle<JSArray> NewJSArrayWithElements( Handle<FixedArrayBase> elements, - ElementsKind elements_kind = TERMINAL_FAST_ELEMENTS_KIND, + ElementsKind elements_kind, + int length, PretenureFlag pretenure = NOT_TENURED); - void SetElementsCapacityAndLength(Handle<JSArray> array, - int capacity, - int length); + Handle<JSArray> NewJSArrayWithElements( + Handle<FixedArrayBase> elements, + ElementsKind elements_kind = TERMINAL_FAST_ELEMENTS_KIND, + PretenureFlag pretenure = NOT_TENURED) { + return NewJSArrayWithElements( + elements, elements_kind, elements->length(), pretenure); + } - void SetContent(Handle<JSArray> array, Handle<FixedArrayBase> elements); + void NewJSArrayStorage( + Handle<JSArray> array, + int length, + int capacity, + ArrayStorageAllocationMode mode = DONT_INITIALIZE_ARRAY_ELEMENTS); Handle<JSGeneratorObject> NewJSGeneratorObject(Handle<JSFunction> function); @@ -355,50 +442,78 @@ class Factory { Handle<JSDataView> NewJSDataView(); + // Allocates a Harmony proxy. Handle<JSProxy> NewJSProxy(Handle<Object> handler, Handle<Object> prototype); + // Allocates a Harmony function proxy. + Handle<JSProxy> NewJSFunctionProxy(Handle<Object> handler, + Handle<Object> call_trap, + Handle<Object> construct_trap, + Handle<Object> prototype); + + // Reinitialize a JSReceiver into an (empty) JS object of respective type and + // size, but keeping the original prototype. The receiver must have at least + // the size of the new object. The object is reinitialized and behaves as an + // object that has been freshly allocated. + void ReinitializeJSReceiver( + Handle<JSReceiver> object, InstanceType type, int size); + + // Reinitialize an JSGlobalProxy based on a constructor. The object + // must have the same size as objects allocated using the + // constructor. The object is reinitialized and behaves as an + // object that has been freshly allocated using the constructor. + void ReinitializeJSGlobalProxy(Handle<JSGlobalProxy> global, + Handle<JSFunction> constructor); + // Change the type of the argument into a JS object/function and reinitialize. void BecomeJSObject(Handle<JSReceiver> object); void BecomeJSFunction(Handle<JSReceiver> object); Handle<JSFunction> NewFunction(Handle<String> name, - Handle<Object> prototype); - - Handle<JSFunction> NewFunctionWithoutPrototype( - Handle<String> name, - LanguageMode language_mode); - - Handle<JSFunction> NewFunction(Handle<Object> super, bool is_global); - - Handle<JSFunction> BaseNewFunctionFromSharedFunctionInfo( - Handle<SharedFunctionInfo> function_info, - Handle<Map> function_map, - PretenureFlag pretenure); + Handle<Code> code, + Handle<Object> prototype, + bool read_only_prototype = false); + Handle<JSFunction> NewFunction(Handle<String> name); + Handle<JSFunction> NewFunctionWithoutPrototype(Handle<String> name, + Handle<Code> code); Handle<JSFunction> NewFunctionFromSharedFunctionInfo( Handle<SharedFunctionInfo> function_info, Handle<Context> context, PretenureFlag pretenure = TENURED); + Handle<JSFunction> NewFunction(Handle<String> name, + Handle<Code> code, + Handle<Object> prototype, + InstanceType type, + int instance_size, + bool read_only_prototype = false); + Handle<JSFunction> NewFunction(Handle<String> name, + Handle<Code> code, + InstanceType type, + int instance_size); + + // Create a serialized scope info. Handle<ScopeInfo> NewScopeInfo(int length); + // Create an External object for V8's external API. Handle<JSObject> NewExternal(void* value); + // The reference to the Code object is stored in self_reference. + // This allows generated code to reference its own Code object + // by containing this handle. Handle<Code> NewCode(const CodeDesc& desc, Code::Flags flags, Handle<Object> self_reference, bool immovable = false, bool crankshafted = false, - int prologue_offset = Code::kPrologueOffsetNotSet); + int prologue_offset = Code::kPrologueOffsetNotSet, + bool is_debug = false); Handle<Code> CopyCode(Handle<Code> code); Handle<Code> CopyCode(Handle<Code> code, Vector<byte> reloc_info); - Handle<Object> ToObject(Handle<Object> object); - Handle<Object> ToObject(Handle<Object> object, - Handle<Context> native_context); - // Interface for creating error objects. Handle<Object> NewError(const char* maker, const char* message, @@ -420,39 +535,30 @@ class Factory { Vector< Handle<Object> > args); Handle<Object> NewRangeError(Handle<String> message); + Handle<Object> NewInvalidStringLengthError() { + return NewRangeError("invalid_string_length", + HandleVector<Object>(NULL, 0)); + } + Handle<Object> NewSyntaxError(const char* message, Handle<JSArray> args); Handle<Object> NewSyntaxError(Handle<String> message); Handle<Object> NewReferenceError(const char* message, Vector< Handle<Object> > args); + Handle<Object> NewReferenceError(const char* message, Handle<JSArray> args); Handle<Object> NewReferenceError(Handle<String> message); Handle<Object> NewEvalError(const char* message, Vector< Handle<Object> > args); + Handle<JSObject> NewIteratorResultObject(Handle<Object> value, bool done); - Handle<JSFunction> NewFunction(Handle<String> name, - InstanceType type, - int instance_size, - Handle<Code> code, - bool force_initial_map); - - Handle<JSFunction> NewFunction(Handle<Map> function_map, - Handle<SharedFunctionInfo> shared, Handle<Object> prototype); - - - Handle<JSFunction> NewFunctionWithPrototype(Handle<String> name, - InstanceType type, - int instance_size, - Handle<JSObject> prototype, - Handle<Code> code, - bool force_initial_map); - - Handle<JSFunction> NewFunctionWithoutPrototype(Handle<String> name, - Handle<Code> code); + Handle<String> NumberToString(Handle<Object> number, + bool check_number_string_cache = true); - Handle<String> NumberToString(Handle<Object> number); - Handle<String> Uint32ToString(uint32_t value); + Handle<String> Uint32ToString(uint32_t value) { + return NumberToString(NewNumberFromUint(value)); + } enum ApiInstanceType { JavaScriptObject, @@ -462,6 +568,7 @@ class Factory { Handle<JSFunction> CreateApiFunction( Handle<FunctionTemplateInfo> data, + Handle<Object> prototype, ApiInstanceType type = JavaScriptObject); Handle<JSFunction> InstallMembers(Handle<JSFunction> function); @@ -469,9 +576,8 @@ class Factory { // Installs interceptors on the instance. 'desc' is a function template, // and instance is an object instance created by the function of this // function template. - void ConfigureInstance(Handle<FunctionTemplateInfo> desc, - Handle<JSObject> instance, - bool* pending_exception); + MUST_USE_RESULT MaybeHandle<FunctionTemplateInfo> ConfigureInstance( + Handle<FunctionTemplateInfo> desc, Handle<JSObject> instance); #define ROOT_ACCESSOR(type, name, camel_name) \ inline Handle<type> name() { \ @@ -497,40 +603,38 @@ class Factory { INTERNALIZED_STRING_LIST(STRING_ACCESSOR) #undef STRING_ACCESSOR + inline void set_string_table(Handle<StringTable> table) { + isolate()->heap()->set_string_table(*table); + } + Handle<String> hidden_string() { return Handle<String>(&isolate()->heap()->hidden_string_); } + // Allocates a new SharedFunctionInfo object. Handle<SharedFunctionInfo> NewSharedFunctionInfo( Handle<String> name, int number_of_literals, bool is_generator, Handle<Code> code, - Handle<ScopeInfo> scope_info); - Handle<SharedFunctionInfo> NewSharedFunctionInfo(Handle<String> name); + Handle<ScopeInfo> scope_info, + Handle<FixedArray> feedback_vector); + Handle<SharedFunctionInfo> NewSharedFunctionInfo(Handle<String> name, + MaybeHandle<Code> code); + + // Allocate a new type feedback vector + Handle<FixedArray> NewTypeFeedbackVector(int slot_count); + // Allocates a new JSMessageObject object. Handle<JSMessageObject> NewJSMessageObject( Handle<String> type, Handle<JSArray> arguments, int start_position, int end_position, Handle<Object> script, - Handle<Object> stack_trace, Handle<Object> stack_frames); - Handle<SeededNumberDictionary> DictionaryAtNumberPut( - Handle<SeededNumberDictionary>, - uint32_t key, - Handle<Object> value); - - Handle<UnseededNumberDictionary> DictionaryAtNumberPut( - Handle<UnseededNumberDictionary>, - uint32_t key, - Handle<Object> value); - -#ifdef ENABLE_DEBUGGER_SUPPORT Handle<DebugInfo> NewDebugInfo(Handle<SharedFunctionInfo> shared); -#endif // Return a map using the map cache in the native context. // The key the an ordered set of property names. @@ -564,12 +668,19 @@ class Factory { private: Isolate* isolate() { return reinterpret_cast<Isolate*>(this); } - Handle<JSFunction> NewFunctionHelper(Handle<String> name, - Handle<Object> prototype); + // Creates a heap object based on the map. The fields of the heap object are + // not initialized by New<>() functions. It's the responsibility of the caller + // to do that. + template<typename T> + Handle<T> New(Handle<Map> map, AllocationSpace space); - Handle<JSFunction> NewFunctionWithoutPrototypeHelper( - Handle<String> name, - LanguageMode language_mode); + template<typename T> + Handle<T> New(Handle<Map> map, + AllocationSpace space, + Handle<AllocationSite> allocation_site); + + // Creates a code object that is not yet fully initialized yet. + inline Handle<Code> NewCodeRaw(int object_size, bool immovable); // Create a new map cache. Handle<MapCache> NewMapCache(int at_least_space_for); @@ -578,19 +689,32 @@ class Factory { Handle<MapCache> AddToMapCache(Handle<Context> context, Handle<FixedArray> keys, Handle<Map> map); -}; - - -Handle<Object> Factory::NewNumberFromSize(size_t value, - PretenureFlag pretenure) { - if (Smi::IsValid(static_cast<intptr_t>(value))) { - return Handle<Object>(Smi::FromIntptr(static_cast<intptr_t>(value)), - isolate()); - } else { - return NewNumber(static_cast<double>(value), pretenure); - } -} + // Attempt to find the number in a small cache. If we finds it, return + // the string representation of the number. Otherwise return undefined. + Handle<Object> GetNumberStringCache(Handle<Object> number); + + // Update the cache with a new number-string pair. + void SetNumberStringCache(Handle<Object> number, Handle<String> string); + + // Initializes a function with a shared part and prototype. + // Note: this code was factored out of NewFunction such that other parts of + // the VM could use it. Specifically, a function that creates instances of + // type JS_FUNCTION_TYPE benefit from the use of this function. + inline void InitializeFunction(Handle<JSFunction> function, + Handle<SharedFunctionInfo> info, + Handle<Context> context); + + // Creates a function initialized with a shared part. + Handle<JSFunction> NewFunction(Handle<Map> map, + Handle<SharedFunctionInfo> info, + Handle<Context> context, + PretenureFlag pretenure = TENURED); + + Handle<JSFunction> NewFunction(Handle<Map> map, + Handle<String> name, + MaybeHandle<Code> maybe_code); +}; } } // namespace v8::internal |