Line data Source code
1 : // Copyright 2012 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 : #include "src/interface-descriptors.h"
6 :
7 : #include "src/macro-assembler.h"
8 :
9 : namespace v8 {
10 : namespace internal {
11 :
12 14299920 : void CallInterfaceDescriptorData::InitializePlatformSpecific(
13 : int register_parameter_count, const Register* registers) {
14 : DCHECK(!IsInitializedPlatformIndependent());
15 :
16 14299920 : register_param_count_ = register_parameter_count;
17 :
18 : // UBSan doesn't like creating zero-length arrays.
19 28599840 : if (register_parameter_count == 0) return;
20 :
21 : // InterfaceDescriptor owns a copy of the registers array.
22 13227426 : register_params_ = NewArray<Register>(register_parameter_count, no_reg);
23 48500562 : for (int i = 0; i < register_parameter_count; i++) {
24 : // The value of the root register must be reserved, thus any uses
25 : // within the calling convention are disallowed.
26 : DCHECK_NE(registers[i], kRootRegister);
27 35273136 : register_params_[i] = registers[i];
28 : }
29 : }
30 :
31 14299920 : void CallInterfaceDescriptorData::InitializePlatformIndependent(
32 : Flags flags, int return_count, int parameter_count,
33 : const MachineType* machine_types, int machine_types_length) {
34 : DCHECK(IsInitializedPlatformSpecific());
35 :
36 14299920 : flags_ = flags;
37 14299920 : return_count_ = return_count;
38 14299920 : param_count_ = parameter_count;
39 14299920 : const int types_length = return_count_ + param_count_;
40 :
41 : // Machine types are either fully initialized or null.
42 14299920 : if (machine_types == nullptr) {
43 : machine_types_ =
44 10486608 : NewArray<MachineType>(types_length, MachineType::AnyTagged());
45 : } else {
46 : DCHECK_EQ(machine_types_length, types_length);
47 3813312 : machine_types_ = NewArray<MachineType>(types_length);
48 3813312 : for (int i = 0; i < types_length; i++) machine_types_[i] = machine_types[i];
49 : }
50 :
51 : if (!(flags_ & kNoStackScan)) DCHECK(AllStackParametersAreTagged());
52 14299920 : }
53 :
54 : #ifdef DEBUG
55 : bool CallInterfaceDescriptorData::AllStackParametersAreTagged() const {
56 : DCHECK(IsInitialized());
57 : const int types_length = return_count_ + param_count_;
58 : const int first_stack_param = return_count_ + register_param_count_;
59 : for (int i = first_stack_param; i < types_length; i++) {
60 : if (!machine_types_[i].IsTagged()) return false;
61 : }
62 : return true;
63 : }
64 : #endif // DEBUG
65 :
66 14043840 : void CallInterfaceDescriptorData::Reset() {
67 14043840 : delete[] machine_types_;
68 14043840 : machine_types_ = nullptr;
69 14043840 : delete[] register_params_;
70 14043840 : register_params_ = nullptr;
71 14043840 : }
72 :
73 : // static
74 : CallInterfaceDescriptorData
75 14361913 : CallDescriptors::call_descriptor_data_[NUMBER_OF_DESCRIPTORS];
76 :
77 59583 : void CallDescriptors::InitializeOncePerProcess() {
78 : #define INTERFACE_DESCRIPTOR(name, ...) \
79 : name##Descriptor().Initialize(&call_descriptor_data_[CallDescriptors::name]);
80 16504491 : INTERFACE_DESCRIPTOR_LIST(INTERFACE_DESCRIPTOR)
81 : #undef INTERFACE_DESCRIPTOR
82 :
83 : DCHECK(ContextOnlyDescriptor{}.HasContextParameter());
84 : DCHECK(!NoContextDescriptor{}.HasContextParameter());
85 : DCHECK(!AllocateDescriptor{}.HasContextParameter());
86 : DCHECK(!AllocateHeapNumberDescriptor{}.HasContextParameter());
87 : DCHECK(!AbortDescriptor{}.HasContextParameter());
88 59583 : }
89 :
90 58516 : void CallDescriptors::TearDown() {
91 14102356 : for (CallInterfaceDescriptorData& data : call_descriptor_data_) {
92 14043840 : data.Reset();
93 : }
94 58516 : }
95 :
96 178749 : void CallInterfaceDescriptor::JSDefaultInitializePlatformSpecific(
97 : CallInterfaceDescriptorData* data, int non_js_register_parameter_count) {
98 : DCHECK_LE(static_cast<unsigned>(non_js_register_parameter_count), 1);
99 :
100 : // 3 is for kTarget, kNewTarget and kActualArgumentsCount
101 178749 : int register_parameter_count = 3 + non_js_register_parameter_count;
102 :
103 : DCHECK(!AreAliased(
104 : kJavaScriptCallTargetRegister, kJavaScriptCallNewTargetRegister,
105 : kJavaScriptCallArgCountRegister, kJavaScriptCallExtraArg1Register));
106 :
107 : const Register default_js_stub_registers[] = {
108 : kJavaScriptCallTargetRegister, kJavaScriptCallNewTargetRegister,
109 178749 : kJavaScriptCallArgCountRegister, kJavaScriptCallExtraArg1Register};
110 :
111 178749 : CHECK_LE(static_cast<size_t>(register_parameter_count),
112 : arraysize(default_js_stub_registers));
113 : data->InitializePlatformSpecific(register_parameter_count,
114 178749 : default_js_stub_registers);
115 178749 : }
116 :
117 3413952 : const char* CallInterfaceDescriptor::DebugName() const {
118 3413952 : CallDescriptors::Key key = CallDescriptors::GetKey(data_);
119 3413952 : switch (key) {
120 : #define DEF_CASE(name, ...) \
121 : case CallDescriptors::name: \
122 : return #name " Descriptor";
123 111813 : INTERFACE_DESCRIPTOR_LIST(DEF_CASE)
124 : #undef DEF_CASE
125 : case CallDescriptors::NUMBER_OF_DESCRIPTORS:
126 : break;
127 : }
128 0 : return "";
129 : }
130 :
131 : #if !defined(V8_TARGET_ARCH_MIPS) && !defined(V8_TARGET_ARCH_MIPS64)
132 0 : bool CallInterfaceDescriptor::IsValidFloatParameterRegister(Register reg) {
133 0 : return true;
134 : }
135 : #endif
136 :
137 59583 : void VoidDescriptor::InitializePlatformSpecific(
138 : CallInterfaceDescriptorData* data) {
139 59583 : data->InitializePlatformSpecific(0, nullptr);
140 59583 : }
141 :
142 59583 : void AllocateDescriptor::InitializePlatformSpecific(
143 : CallInterfaceDescriptorData* data) {
144 59583 : Register registers[] = {kAllocateSizeRegister};
145 59583 : data->InitializePlatformSpecific(arraysize(registers), registers);
146 59583 : }
147 :
148 59583 : void CEntry1ArgvOnStackDescriptor::InitializePlatformSpecific(
149 : CallInterfaceDescriptorData* data) {
150 : Register registers[] = {kRuntimeCallArgCountRegister,
151 59583 : kRuntimeCallFunctionRegister};
152 59583 : data->InitializePlatformSpecific(arraysize(registers), registers);
153 59583 : }
154 :
155 : namespace {
156 :
157 : void InterpreterCEntryDescriptor_InitializePlatformSpecific(
158 : CallInterfaceDescriptorData* data) {
159 : Register registers[] = {kRuntimeCallArgCountRegister,
160 : kRuntimeCallArgvRegister,
161 119166 : kRuntimeCallFunctionRegister};
162 119166 : data->InitializePlatformSpecific(arraysize(registers), registers);
163 : }
164 :
165 : } // namespace
166 :
167 59583 : void InterpreterCEntry1Descriptor::InitializePlatformSpecific(
168 : CallInterfaceDescriptorData* data) {
169 : InterpreterCEntryDescriptor_InitializePlatformSpecific(data);
170 59583 : }
171 :
172 59583 : void InterpreterCEntry2Descriptor::InitializePlatformSpecific(
173 : CallInterfaceDescriptorData* data) {
174 : InterpreterCEntryDescriptor_InitializePlatformSpecific(data);
175 59583 : }
176 :
177 59583 : void FastNewFunctionContextDescriptor::InitializePlatformSpecific(
178 : CallInterfaceDescriptorData* data) {
179 59583 : Register registers[] = {ScopeInfoRegister(), SlotsRegister()};
180 59583 : data->InitializePlatformSpecific(arraysize(registers), registers);
181 59583 : }
182 :
183 59583 : void FastNewObjectDescriptor::InitializePlatformSpecific(
184 : CallInterfaceDescriptorData* data) {
185 59583 : Register registers[] = {TargetRegister(), NewTargetRegister()};
186 59583 : data->InitializePlatformSpecific(arraysize(registers), registers);
187 59583 : }
188 :
189 0 : const Register FastNewObjectDescriptor::TargetRegister() {
190 0 : return kJSFunctionRegister;
191 : }
192 :
193 0 : const Register FastNewObjectDescriptor::NewTargetRegister() {
194 0 : return kJavaScriptCallNewTargetRegister;
195 : }
196 :
197 :
198 59583 : void LoadDescriptor::InitializePlatformSpecific(
199 : CallInterfaceDescriptorData* data) {
200 59583 : Register registers[] = {ReceiverRegister(), NameRegister(), SlotRegister()};
201 59583 : data->InitializePlatformSpecific(arraysize(registers), registers);
202 59583 : }
203 :
204 59583 : void LoadGlobalDescriptor::InitializePlatformSpecific(
205 : CallInterfaceDescriptorData* data) {
206 119166 : Register registers[] = {NameRegister(), SlotRegister()};
207 59583 : data->InitializePlatformSpecific(arraysize(registers), registers);
208 59583 : }
209 :
210 59583 : void LoadGlobalWithVectorDescriptor::InitializePlatformSpecific(
211 : CallInterfaceDescriptorData* data) {
212 178749 : Register registers[] = {NameRegister(), SlotRegister(), VectorRegister()};
213 59583 : data->InitializePlatformSpecific(arraysize(registers), registers);
214 59583 : }
215 :
216 59583 : void StoreGlobalDescriptor::InitializePlatformSpecific(
217 : CallInterfaceDescriptorData* data) {
218 178749 : Register registers[] = {NameRegister(), ValueRegister(), SlotRegister()};
219 :
220 : int len = arraysize(registers) - kStackArgumentsCount;
221 59583 : data->InitializePlatformSpecific(len, registers);
222 59583 : }
223 :
224 59583 : void StoreGlobalWithVectorDescriptor::InitializePlatformSpecific(
225 : CallInterfaceDescriptorData* data) {
226 : Register registers[] = {NameRegister(), ValueRegister(), SlotRegister(),
227 238332 : VectorRegister()};
228 : int len = arraysize(registers) - kStackArgumentsCount;
229 59583 : data->InitializePlatformSpecific(len, registers);
230 59583 : }
231 :
232 59583 : void StoreDescriptor::InitializePlatformSpecific(
233 : CallInterfaceDescriptorData* data) {
234 : Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(),
235 59583 : SlotRegister()};
236 :
237 : int len = arraysize(registers) - kStackArgumentsCount;
238 59583 : data->InitializePlatformSpecific(len, registers);
239 59583 : }
240 :
241 59583 : void StoreTransitionDescriptor::InitializePlatformSpecific(
242 : CallInterfaceDescriptorData* data) {
243 : Register registers[] = {
244 : ReceiverRegister(), NameRegister(), MapRegister(),
245 : ValueRegister(), SlotRegister(), VectorRegister(),
246 59583 : };
247 : int len = arraysize(registers) - kStackArgumentsCount;
248 59583 : data->InitializePlatformSpecific(len, registers);
249 59583 : }
250 :
251 59583 : void StringAtDescriptor::InitializePlatformSpecific(
252 : CallInterfaceDescriptorData* data) {
253 59583 : DefaultInitializePlatformSpecific(data, kParameterCount);
254 59583 : }
255 :
256 59583 : void StringSubstringDescriptor::InitializePlatformSpecific(
257 : CallInterfaceDescriptorData* data) {
258 59583 : DefaultInitializePlatformSpecific(data, kParameterCount);
259 59583 : }
260 :
261 59583 : void TypeConversionDescriptor::InitializePlatformSpecific(
262 : CallInterfaceDescriptorData* data) {
263 59583 : Register registers[] = {ArgumentRegister()};
264 59583 : data->InitializePlatformSpecific(arraysize(registers), registers);
265 59583 : }
266 :
267 59583 : void TypeConversionStackParameterDescriptor::InitializePlatformSpecific(
268 : CallInterfaceDescriptorData* data) {
269 59583 : data->InitializePlatformSpecific(0, nullptr);
270 59583 : }
271 :
272 59583 : void AsyncFunctionStackParameterDescriptor::InitializePlatformSpecific(
273 : CallInterfaceDescriptorData* data) {
274 59583 : data->InitializePlatformSpecific(0, nullptr);
275 59583 : }
276 :
277 59583 : void LoadWithVectorDescriptor::InitializePlatformSpecific(
278 : CallInterfaceDescriptorData* data) {
279 : Register registers[] = {ReceiverRegister(), NameRegister(), SlotRegister(),
280 59583 : VectorRegister()};
281 : // TODO(jgruber): This DCHECK could be enabled if RegisterBase::ListOf were
282 : // to allow no_reg entries.
283 : // DCHECK(!AreAliased(ReceiverRegister(), NameRegister(), SlotRegister(),
284 : // VectorRegister(), kRootRegister));
285 : int len = arraysize(registers) - kStackArgumentsCount;
286 59583 : data->InitializePlatformSpecific(len, registers);
287 59583 : }
288 :
289 59583 : void StoreWithVectorDescriptor::InitializePlatformSpecific(
290 : CallInterfaceDescriptorData* data) {
291 : Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(),
292 59583 : SlotRegister(), VectorRegister()};
293 : // TODO(jgruber): This DCHECK could be enabled if RegisterBase::ListOf were
294 : // to allow no_reg entries.
295 : // DCHECK(!AreAliased(ReceiverRegister(), NameRegister(), kRootRegister));
296 : int len = arraysize(registers) - kStackArgumentsCount;
297 59583 : data->InitializePlatformSpecific(len, registers);
298 59583 : }
299 :
300 56 : const Register ApiGetterDescriptor::ReceiverRegister() {
301 59639 : return LoadDescriptor::ReceiverRegister();
302 : }
303 :
304 59583 : void ApiGetterDescriptor::InitializePlatformSpecific(
305 : CallInterfaceDescriptorData* data) {
306 : Register registers[] = {ReceiverRegister(), HolderRegister(),
307 59583 : CallbackRegister()};
308 59583 : data->InitializePlatformSpecific(arraysize(registers), registers);
309 59583 : }
310 :
311 59583 : void ContextOnlyDescriptor::InitializePlatformSpecific(
312 : CallInterfaceDescriptorData* data) {
313 59583 : data->InitializePlatformSpecific(0, nullptr);
314 59583 : }
315 :
316 59583 : void NoContextDescriptor::InitializePlatformSpecific(
317 : CallInterfaceDescriptorData* data) {
318 59583 : data->InitializePlatformSpecific(0, nullptr);
319 59583 : }
320 :
321 59583 : void GrowArrayElementsDescriptor::InitializePlatformSpecific(
322 : CallInterfaceDescriptorData* data) {
323 59583 : Register registers[] = {ObjectRegister(), KeyRegister()};
324 59583 : data->InitializePlatformSpecific(arraysize(registers), registers);
325 59583 : }
326 :
327 59583 : void NewArgumentsElementsDescriptor::InitializePlatformSpecific(
328 : CallInterfaceDescriptorData* data) {
329 59583 : DefaultInitializePlatformSpecific(data, kParameterCount);
330 59583 : }
331 :
332 59583 : void ArrayNoArgumentConstructorDescriptor::InitializePlatformSpecific(
333 : CallInterfaceDescriptorData* data) {
334 : // This descriptor must use the same set of registers as the
335 : // ArrayNArgumentsConstructorDescriptor.
336 : ArrayNArgumentsConstructorDescriptor::InitializePlatformSpecific(data);
337 59583 : }
338 :
339 59583 : void ArraySingleArgumentConstructorDescriptor::InitializePlatformSpecific(
340 : CallInterfaceDescriptorData* data) {
341 : // This descriptor must use the same set of registers as the
342 : // ArrayNArgumentsConstructorDescriptor.
343 : ArrayNArgumentsConstructorDescriptor::InitializePlatformSpecific(data);
344 59583 : }
345 :
346 59583 : void ArrayNArgumentsConstructorDescriptor::InitializePlatformSpecific(
347 : CallInterfaceDescriptorData* data) {
348 : // Keep the arguments on the same registers as they were in
349 : // ArrayConstructorDescriptor to avoid unnecessary register moves.
350 : // kFunction, kAllocationSite, kActualArgumentsCount
351 : Register registers[] = {kJavaScriptCallTargetRegister,
352 : kJavaScriptCallExtraArg1Register,
353 178749 : kJavaScriptCallArgCountRegister};
354 178749 : data->InitializePlatformSpecific(arraysize(registers), registers);
355 59583 : }
356 :
357 59583 : void WasmMemoryGrowDescriptor::InitializePlatformSpecific(
358 : CallInterfaceDescriptorData* data) {
359 59583 : DefaultInitializePlatformSpecific(data, kParameterCount);
360 59583 : }
361 :
362 59583 : void WasmThrowDescriptor::InitializePlatformSpecific(
363 : CallInterfaceDescriptorData* data) {
364 59583 : DefaultInitializePlatformSpecific(data, kParameterCount);
365 59583 : }
366 :
367 59583 : void WasmAtomicWakeDescriptor::InitializePlatformSpecific(
368 : CallInterfaceDescriptorData* data) {
369 59583 : DefaultInitializePlatformSpecific(data, kParameterCount);
370 59583 : }
371 :
372 : #if !defined(V8_TARGET_ARCH_MIPS) && !defined(V8_TARGET_ARCH_MIPS64)
373 59583 : void WasmI32AtomicWaitDescriptor::InitializePlatformSpecific(
374 : CallInterfaceDescriptorData* data) {
375 59583 : DefaultInitializePlatformSpecific(data, kParameterCount);
376 59583 : }
377 :
378 59583 : void WasmI64AtomicWaitDescriptor::InitializePlatformSpecific(
379 : CallInterfaceDescriptorData* data) {
380 59583 : DefaultInitializePlatformSpecific(data, kParameterCount);
381 59583 : }
382 : #endif
383 :
384 59583 : void CloneObjectWithVectorDescriptor::InitializePlatformSpecific(
385 : CallInterfaceDescriptorData* data) {
386 59583 : DefaultInitializePlatformSpecific(data, kParameterCount);
387 59583 : }
388 :
389 : // static
390 56 : Register RunMicrotasksDescriptor::MicrotaskQueueRegister() {
391 : return CallDescriptors::call_descriptor_data(CallDescriptors::RunMicrotasks)
392 112 : ->register_param(0);
393 : }
394 :
395 59583 : void RunMicrotasksDescriptor::InitializePlatformSpecific(
396 : CallInterfaceDescriptorData* data) {
397 59583 : DefaultInitializePlatformSpecific(data, kParameterCount);
398 59583 : }
399 :
400 59583 : void BigIntToWasmI64Descriptor::InitializePlatformSpecific(
401 : CallInterfaceDescriptorData* data) {
402 59583 : DefaultInitializePlatformSpecific(data, kParameterCount);
403 59583 : }
404 :
405 59583 : void BigIntToI64Descriptor::InitializePlatformSpecific(
406 : CallInterfaceDescriptorData* data) {
407 59583 : DefaultInitializePlatformSpecific(data, kParameterCount);
408 59583 : }
409 :
410 : } // namespace internal
411 178779 : } // namespace v8
|
