1 // Copyright 2017 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifndef V8_HEAP_FACTORY_INL_H_
6 #define V8_HEAP_FACTORY_INL_H_
7
8 #include "src/heap/factory.h"
9
10 #include "src/handles-inl.h"
11 #include "src/objects-inl.h"
12 #include "src/string-hasher.h"
13
14 namespace v8 {
15 namespace internal {
16
17 #define ROOT_ACCESSOR(type, name, camel_name) \
18 Handle<type> Factory::name() { \
19 return Handle<type>(bit_cast<type**>( \
20 &isolate()->heap()->roots_[Heap::k##camel_name##RootIndex])); \
21 }
22 ROOT_LIST(ROOT_ACCESSOR)
23 #undef ROOT_ACCESSOR
24
25 #define STRUCT_MAP_ACCESSOR(NAME, Name, name) \
26 Handle<Map> Factory::name##_map() { \
27 return Handle<Map>(bit_cast<Map**>( \
28 &isolate()->heap()->roots_[Heap::k##Name##MapRootIndex])); \
29 }
STRUCT_LIST(STRUCT_MAP_ACCESSOR)30 STRUCT_LIST(STRUCT_MAP_ACCESSOR)
31 #undef STRUCT_MAP_ACCESSOR
32
33 #define DATA_HANDLER_MAP_ACCESSOR(NAME, Name, Size, name) \
34 Handle<Map> Factory::name##_map() { \
35 return Handle<Map>(bit_cast<Map**>( \
36 &isolate()->heap()->roots_[Heap::k##Name##Size##MapRootIndex])); \
37 }
38 DATA_HANDLER_LIST(DATA_HANDLER_MAP_ACCESSOR)
39 #undef DATA_HANDLER_MAP_ACCESSOR
40
41 #define STRING_ACCESSOR(name, str) \
42 Handle<String> Factory::name() { \
43 return Handle<String>(bit_cast<String**>( \
44 &isolate()->heap()->roots_[Heap::k##name##RootIndex])); \
45 }
46 INTERNALIZED_STRING_LIST(STRING_ACCESSOR)
47 #undef STRING_ACCESSOR
48
49 #define SYMBOL_ACCESSOR(name) \
50 Handle<Symbol> Factory::name() { \
51 return Handle<Symbol>(bit_cast<Symbol**>( \
52 &isolate()->heap()->roots_[Heap::k##name##RootIndex])); \
53 }
54 PRIVATE_SYMBOL_LIST(SYMBOL_ACCESSOR)
55 #undef SYMBOL_ACCESSOR
56
57 #define SYMBOL_ACCESSOR(name, description) \
58 Handle<Symbol> Factory::name() { \
59 return Handle<Symbol>(bit_cast<Symbol**>( \
60 &isolate()->heap()->roots_[Heap::k##name##RootIndex])); \
61 }
62 PUBLIC_SYMBOL_LIST(SYMBOL_ACCESSOR)
63 WELL_KNOWN_SYMBOL_LIST(SYMBOL_ACCESSOR)
64 #undef SYMBOL_ACCESSOR
65
66 #define ACCESSOR_INFO_ACCESSOR(accessor_name, AccessorName) \
67 Handle<AccessorInfo> Factory::accessor_name##_accessor() { \
68 return Handle<AccessorInfo>(bit_cast<AccessorInfo**>( \
69 &isolate() \
70 ->heap() \
71 ->roots_[Heap::k##AccessorName##AccessorRootIndex])); \
72 }
73 ACCESSOR_INFO_LIST(ACCESSOR_INFO_ACCESSOR)
74 #undef ACCESSOR_INFO_ACCESSOR
75
76 Handle<String> Factory::InternalizeString(Handle<String> string) {
77 if (string->IsInternalizedString()) return string;
78 return StringTable::LookupString(isolate(), string);
79 }
80
InternalizeName(Handle<Name> name)81 Handle<Name> Factory::InternalizeName(Handle<Name> name) {
82 if (name->IsUniqueName()) return name;
83 return StringTable::LookupString(isolate(), Handle<String>::cast(name));
84 }
85
NewSubString(Handle<String> str,int begin,int end)86 Handle<String> Factory::NewSubString(Handle<String> str, int begin, int end) {
87 if (begin == 0 && end == str->length()) return str;
88 return NewProperSubString(str, begin, end);
89 }
90
NewNumberFromSize(size_t value,PretenureFlag pretenure)91 Handle<Object> Factory::NewNumberFromSize(size_t value,
92 PretenureFlag pretenure) {
93 // We can't use Smi::IsValid() here because that operates on a signed
94 // intptr_t, and casting from size_t could create a bogus sign bit.
95 if (value <= static_cast<size_t>(Smi::kMaxValue)) {
96 return Handle<Object>(Smi::FromIntptr(static_cast<intptr_t>(value)),
97 isolate());
98 }
99 return NewNumber(static_cast<double>(value), pretenure);
100 }
101
NewNumberFromInt64(int64_t value,PretenureFlag pretenure)102 Handle<Object> Factory::NewNumberFromInt64(int64_t value,
103 PretenureFlag pretenure) {
104 if (value <= std::numeric_limits<int32_t>::max() &&
105 value >= std::numeric_limits<int32_t>::min() &&
106 Smi::IsValid(static_cast<int32_t>(value))) {
107 return Handle<Object>(Smi::FromInt(static_cast<int32_t>(value)), isolate());
108 }
109 return NewNumber(static_cast<double>(value), pretenure);
110 }
111
NewHeapNumber(double value,MutableMode mode,PretenureFlag pretenure)112 Handle<HeapNumber> Factory::NewHeapNumber(double value, MutableMode mode,
113 PretenureFlag pretenure) {
114 Handle<HeapNumber> heap_number = NewHeapNumber(mode, pretenure);
115 heap_number->set_value(value);
116 return heap_number;
117 }
118
NewHeapNumberFromBits(uint64_t bits,MutableMode mode,PretenureFlag pretenure)119 Handle<HeapNumber> Factory::NewHeapNumberFromBits(uint64_t bits,
120 MutableMode mode,
121 PretenureFlag pretenure) {
122 Handle<HeapNumber> heap_number = NewHeapNumber(mode, pretenure);
123 heap_number->set_value_as_bits(bits);
124 return heap_number;
125 }
126
NewMutableHeapNumber(PretenureFlag pretenure)127 Handle<HeapNumber> Factory::NewMutableHeapNumber(PretenureFlag pretenure) {
128 return NewHeapNumberFromBits(kHoleNanInt64, MUTABLE, pretenure);
129 }
130
NewJSArrayWithElements(Handle<FixedArrayBase> elements,ElementsKind elements_kind,PretenureFlag pretenure)131 Handle<JSArray> Factory::NewJSArrayWithElements(Handle<FixedArrayBase> elements,
132 ElementsKind elements_kind,
133 PretenureFlag pretenure) {
134 return NewJSArrayWithElements(elements, elements_kind, elements->length(),
135 pretenure);
136 }
137
NewURIError()138 Handle<Object> Factory::NewURIError() {
139 return NewError(isolate()->uri_error_function(),
140 MessageTemplate::kURIMalformed);
141 }
142
Uint32ToString(uint32_t value)143 Handle<String> Factory::Uint32ToString(uint32_t value) {
144 Handle<String> result = NumberToString(NewNumberFromUint(value));
145
146 if (result->length() <= String::kMaxArrayIndexSize &&
147 result->hash_field() == String::kEmptyHashField) {
148 uint32_t field = StringHasher::MakeArrayIndexHash(value, result->length());
149 result->set_hash_field(field);
150 }
151 return result;
152 }
153
154 } // namespace internal
155 } // namespace v8
156
157 #endif // V8_HEAP_FACTORY_INL_H_
158