Line data Source code
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 : // Clients of this interface shouldn't depend on lots of heap internals.
11 : // Do not include anything from src/heap here!
12 : #include "src/handles-inl.h"
13 : #include "src/isolate-inl.h"
14 : #include "src/objects-inl.h"
15 : #include "src/objects/feedback-cell.h"
16 : #include "src/objects/heap-number-inl.h"
17 : #include "src/objects/oddball.h"
18 : #include "src/objects/string-inl.h"
19 : #include "src/string-hasher.h"
20 :
21 : namespace v8 {
22 : namespace internal {
23 :
24 : #define ROOT_ACCESSOR(Type, name, CamelName) \
25 : Handle<Type> Factory::name() { \
26 : return Handle<Type>(&isolate()->roots_table()[RootIndex::k##CamelName]); \
27 : }
28 1175778080 : ROOT_LIST(ROOT_ACCESSOR)
29 : #undef ROOT_ACCESSOR
30 :
31 28962067 : Handle<String> Factory::InternalizeString(Handle<String> string) {
32 57924134 : if (string->IsInternalizedString()) return string;
33 3933309 : return StringTable::LookupString(isolate(), string);
34 : }
35 :
36 94943769 : Handle<Name> Factory::InternalizeName(Handle<Name> name) {
37 94943769 : if (name->IsUniqueName()) return name;
38 7358251 : return StringTable::LookupString(isolate(), Handle<String>::cast(name));
39 : }
40 :
41 2716902 : Handle<String> Factory::NewSubString(Handle<String> str, int begin, int end) {
42 3021428 : if (begin == 0 && end == str->length()) return str;
43 2595702 : return NewProperSubString(str, begin, end);
44 : }
45 :
46 97019 : Handle<Object> Factory::NewNumberFromSize(size_t value,
47 : PretenureFlag pretenure) {
48 : // We can't use Smi::IsValid() here because that operates on a signed
49 : // intptr_t, and casting from size_t could create a bogus sign bit.
50 97019 : if (value <= static_cast<size_t>(Smi::kMaxValue)) {
51 : return Handle<Object>(Smi::FromIntptr(static_cast<intptr_t>(value)),
52 97001 : isolate());
53 : }
54 18 : return NewNumber(static_cast<double>(value), pretenure);
55 : }
56 :
57 20034 : Handle<Object> Factory::NewNumberFromInt64(int64_t value,
58 : PretenureFlag pretenure) {
59 19917 : if (value <= std::numeric_limits<int32_t>::max() &&
60 20034 : value >= std::numeric_limits<int32_t>::min() &&
61 : Smi::IsValid(static_cast<int32_t>(value))) {
62 39834 : return Handle<Object>(Smi::FromInt(static_cast<int32_t>(value)), isolate());
63 : }
64 117 : return NewNumber(static_cast<double>(value), pretenure);
65 : }
66 :
67 4413932 : Handle<HeapNumber> Factory::NewHeapNumber(double value,
68 : PretenureFlag pretenure) {
69 4413932 : Handle<HeapNumber> heap_number = NewHeapNumber(pretenure);
70 224 : heap_number->set_value(value);
71 4413932 : return heap_number;
72 : }
73 :
74 28 : Handle<MutableHeapNumber> Factory::NewMutableHeapNumber(
75 : double value, PretenureFlag pretenure) {
76 28 : Handle<MutableHeapNumber> number = NewMutableHeapNumber(pretenure);
77 : number->set_value(value);
78 28 : return number;
79 : }
80 :
81 2921 : Handle<HeapNumber> Factory::NewHeapNumberFromBits(uint64_t bits,
82 : PretenureFlag pretenure) {
83 2921 : Handle<HeapNumber> heap_number = NewHeapNumber(pretenure);
84 56 : heap_number->set_value_as_bits(bits);
85 2921 : return heap_number;
86 : }
87 :
88 11748 : Handle<MutableHeapNumber> Factory::NewMutableHeapNumberFromBits(
89 : uint64_t bits, PretenureFlag pretenure) {
90 11748 : Handle<MutableHeapNumber> number = NewMutableHeapNumber(pretenure);
91 : number->set_value_as_bits(bits);
92 11748 : return number;
93 : }
94 :
95 : Handle<MutableHeapNumber> Factory::NewMutableHeapNumberWithHoleNaN(
96 : PretenureFlag pretenure) {
97 9231 : return NewMutableHeapNumberFromBits(kHoleNanInt64, pretenure);
98 : }
99 :
100 1898255 : Handle<JSArray> Factory::NewJSArrayWithElements(Handle<FixedArrayBase> elements,
101 : ElementsKind elements_kind,
102 : PretenureFlag pretenure) {
103 : return NewJSArrayWithElements(elements, elements_kind, elements->length(),
104 1898255 : pretenure);
105 : }
106 :
107 5244 : Handle<Object> Factory::NewURIError() {
108 : return NewError(isolate()->uri_error_function(),
109 5244 : MessageTemplate::kURIMalformed);
110 : }
111 :
112 5194397 : Handle<String> Factory::Uint32ToString(uint32_t value, bool check_cache) {
113 : Handle<String> result;
114 5194397 : int32_t int32v = static_cast<int32_t>(value);
115 5194397 : if (int32v >= 0 && Smi::IsValid(int32v)) {
116 10386810 : result = NumberToString(Smi::FromInt(int32v), check_cache);
117 : } else {
118 992 : result = NumberToString(NewNumberFromUint(value), check_cache);
119 : }
120 :
121 10388794 : if (result->length() <= String::kMaxArrayIndexSize &&
122 : result->hash_field() == String::kEmptyHashField) {
123 578634 : uint32_t field = StringHasher::MakeArrayIndexHash(value, result->length());
124 : result->set_hash_field(field);
125 : }
126 5194397 : return result;
127 : }
128 :
129 : } // namespace internal
130 : } // namespace v8
131 :
132 : #endif // V8_HEAP_FACTORY_INL_H_
|