1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "ecmascript/builtins/builtins_ark_tools.h"
17
18 #include <sys/types.h>
19 #include <sys/stat.h>
20 #include <fcntl.h>
21 #include "ecmascript/element_accessor-inl.h"
22 #include "ecmascript/js_function.h"
23 #include "ecmascript/base/string_helper.h"
24 #include "ecmascript/js_tagged_value-inl.h"
25 #include "ecmascript/mem/tagged_object-inl.h"
26 #include "ecmascript/napi/include/dfx_jsnapi.h"
27 #include "ecmascript/mem/clock_scope.h"
28 #include "ecmascript/property_detector-inl.h"
29 #include "ecmascript/js_arraybuffer.h"
30 #include "ecmascript/interpreter/fast_runtime_stub-inl.h"
31 #include "builtins_typedarray.h"
32 #include "ecmascript/jit/jit.h"
33
34 namespace panda::ecmascript::builtins {
35 using StringHelper = base::StringHelper;
36
37 #if defined(ECMASCRIPT_SUPPORT_CPUPROFILER)
38 constexpr char FILEDIR[] = "/data/storage/el2/base/files/";
39 #endif
ObjectDump(EcmaRuntimeCallInfo * info)40 JSTaggedValue BuiltinsArkTools::ObjectDump(EcmaRuntimeCallInfo *info)
41 {
42 ASSERT(info);
43 JSThread *thread = info->GetThread();
44 [[maybe_unused]] EcmaHandleScope handleScope(thread);
45
46 JSHandle<EcmaString> str = JSTaggedValue::ToString(thread, GetCallArg(info, 0));
47 RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
48 // The default log level of ace_engine and js_runtime is error
49 LOG_ECMA(ERROR) << ": " << EcmaStringAccessor(str).ToStdString();
50
51 uint32_t numArgs = info->GetArgsNumber();
52 for (uint32_t i = 1; i < numArgs; i++) {
53 JSHandle<JSTaggedValue> obj = GetCallArg(info, i);
54 std::ostringstream oss;
55 obj->Dump(oss);
56
57 // The default log level of ace_engine and js_runtime is error
58 LOG_ECMA(ERROR) << ": " << oss.str();
59 }
60
61 return JSTaggedValue::Undefined();
62 }
63
CompareHClass(EcmaRuntimeCallInfo * info)64 JSTaggedValue BuiltinsArkTools::CompareHClass(EcmaRuntimeCallInfo *info)
65 {
66 ASSERT(info);
67 JSThread *thread = info->GetThread();
68 [[maybe_unused]] EcmaHandleScope handleScope(thread);
69
70 JSHandle<JSTaggedValue> obj1 = GetCallArg(info, 0);
71 JSHandle<JSTaggedValue> obj2 = GetCallArg(info, 1);
72 JSHClass *obj1Hclass = obj1->GetTaggedObject()->GetClass();
73 JSHClass *obj2Hclass = obj2->GetTaggedObject()->GetClass();
74 std::ostringstream oss;
75 obj1Hclass->Dump(oss);
76 obj2Hclass->Dump(oss);
77 bool res = (obj1Hclass == obj2Hclass);
78 if (!res) {
79 LOG_ECMA(ERROR) << "These two object don't share the same hclass:" << oss.str();
80 }
81 return JSTaggedValue(res);
82 }
83
DumpHClass(EcmaRuntimeCallInfo * info)84 JSTaggedValue BuiltinsArkTools::DumpHClass(EcmaRuntimeCallInfo *info)
85 {
86 ASSERT(info);
87 JSThread *thread = info->GetThread();
88 [[maybe_unused]] EcmaHandleScope handleScope(thread);
89
90 JSHandle<JSTaggedValue> obj = GetCallArg(info, 0);
91 JSHClass *objHclass = obj->GetTaggedObject()->GetClass();
92 std::ostringstream oss;
93 objHclass->Dump(oss);
94
95 LOG_ECMA(ERROR) << "hclass:" << oss.str();
96 return JSTaggedValue::Undefined();
97 }
98
IsTSHClass(EcmaRuntimeCallInfo * info)99 JSTaggedValue BuiltinsArkTools::IsTSHClass(EcmaRuntimeCallInfo *info)
100 {
101 ASSERT(info);
102 JSThread *thread = info->GetThread();
103 [[maybe_unused]] EcmaHandleScope handleScope(thread);
104
105 ASSERT(info->GetArgsNumber() == 1);
106 JSHandle<JSTaggedValue> object = GetCallArg(info, 0);
107 JSHClass *hclass = object->GetTaggedObject()->GetClass();
108 bool isTSHClass = hclass->IsTS();
109 return GetTaggedBoolean(isTSHClass);
110 }
111
GetHClass(EcmaRuntimeCallInfo * info)112 JSTaggedValue BuiltinsArkTools::GetHClass(EcmaRuntimeCallInfo *info)
113 {
114 ASSERT(info);
115 JSThread *thread = info->GetThread();
116 [[maybe_unused]] EcmaHandleScope handleScope(thread);
117
118 ASSERT(info->GetArgsNumber() == 1);
119 JSHandle<JSTaggedValue> object = GetCallArg(info, 0);
120 JSHClass *hclass = object->GetTaggedObject()->GetClass();
121 return JSTaggedValue(hclass);
122 }
123
HasTSSubtyping(EcmaRuntimeCallInfo * info)124 JSTaggedValue BuiltinsArkTools::HasTSSubtyping(EcmaRuntimeCallInfo *info)
125 {
126 ASSERT(info);
127 JSThread *thread = info->GetThread();
128 [[maybe_unused]] EcmaHandleScope handleScope(thread);
129
130 ASSERT(info->GetArgsNumber() == 1);
131 JSHandle<JSTaggedValue> object = GetCallArg(info, 0);
132 JSHClass *hclass = object->GetTaggedObject()->GetClass();
133 return GetTaggedBoolean(hclass->HasTSSubtyping());
134 }
135
IsSlicedString(EcmaRuntimeCallInfo * info)136 JSTaggedValue BuiltinsArkTools::IsSlicedString(EcmaRuntimeCallInfo *info)
137 {
138 ASSERT(info);
139 JSThread *thread = info->GetThread();
140 [[maybe_unused]] EcmaHandleScope handleScope(thread);
141
142 ASSERT(info->GetArgsNumber() == 1);
143 JSHandle<JSTaggedValue> str = GetCallArg(info, 0);
144 return GetTaggedBoolean(str->IsSlicedString());
145 }
146
IsNotHoleProperty(EcmaRuntimeCallInfo * info)147 JSTaggedValue BuiltinsArkTools::IsNotHoleProperty(EcmaRuntimeCallInfo *info)
148 {
149 [[maybe_unused]] DisallowGarbageCollection noGc;
150 ASSERT(info);
151 JSThread *thread = info->GetThread();
152 [[maybe_unused]] EcmaHandleScope handleScope(thread);
153
154 ASSERT(info->GetArgsNumber() == 2); // 2 : object and key
155 JSHandle<JSTaggedValue> object = GetCallArg(info, 0);
156 JSTaggedValue key = GetCallArg(info, 1).GetTaggedValue();
157 JSHClass *hclass = object->GetTaggedObject()->GetClass();
158 int entry = JSHClass::FindPropertyEntry(thread, hclass, key);
159 if (entry == -1) {
160 return GetTaggedBoolean(false);
161 }
162 PropertyAttributes attr = LayoutInfo::Cast(hclass->GetLayout().GetTaggedObject())->GetAttr(entry);
163 return GetTaggedBoolean(attr.IsNotHole());
164 }
165
HiddenStackSourceFile(EcmaRuntimeCallInfo * info)166 JSTaggedValue BuiltinsArkTools::HiddenStackSourceFile(EcmaRuntimeCallInfo *info)
167 {
168 [[maybe_unused]] DisallowGarbageCollection noGc;
169 ASSERT(info);
170 JSThread *thread = info->GetThread();
171 thread->SetEnableStackSourceFile(false);
172 return JSTaggedValue::True();
173 }
174
ExcutePendingJob(EcmaRuntimeCallInfo * info)175 JSTaggedValue BuiltinsArkTools::ExcutePendingJob(EcmaRuntimeCallInfo *info)
176 {
177 ASSERT(info);
178 JSThread *thread = info->GetThread();
179 [[maybe_unused]] EcmaHandleScope handleScope(thread);
180
181 thread->GetCurrentEcmaContext()->ExecutePromisePendingJob();
182 return JSTaggedValue::True();
183 }
184
GetLexicalEnv(EcmaRuntimeCallInfo * info)185 JSTaggedValue BuiltinsArkTools::GetLexicalEnv(EcmaRuntimeCallInfo *info)
186 {
187 ASSERT(info);
188 JSThread *thread = info->GetThread();
189 [[maybe_unused]] EcmaHandleScope handleScope(thread);
190
191 ASSERT(info->GetArgsNumber() == 1);
192 JSHandle<JSTaggedValue> object = GetCallArg(info, 0);
193 if (object->IsHeapObject() && object->IsJSFunction()) {
194 JSHandle<JSFunction> function = JSHandle<JSFunction>::Cast(object);
195 return function->GetLexicalEnv();
196 }
197 return JSTaggedValue::Null();
198 }
199
ForceFullGC(EcmaRuntimeCallInfo * info)200 JSTaggedValue BuiltinsArkTools::ForceFullGC(EcmaRuntimeCallInfo *info)
201 {
202 ASSERT(info);
203 const_cast<Heap *>(info->GetThread()->GetEcmaVM()->GetHeap())->CollectGarbage(
204 TriggerGCType::FULL_GC, GCReason::EXTERNAL_TRIGGER);
205 return JSTaggedValue::True();
206 }
207
HintGC(EcmaRuntimeCallInfo * info)208 JSTaggedValue BuiltinsArkTools::HintGC(EcmaRuntimeCallInfo *info)
209 {
210 ASSERT(info);
211 return JSTaggedValue(const_cast<Heap *>(info->GetThread()->GetEcmaVM()->GetHeap())->
212 CheckAndTriggerHintGC());
213 }
214
RemoveAOTFlag(EcmaRuntimeCallInfo * info)215 JSTaggedValue BuiltinsArkTools::RemoveAOTFlag(EcmaRuntimeCallInfo *info)
216 {
217 ASSERT(info);
218 JSThread *thread = info->GetThread();
219 [[maybe_unused]] EcmaHandleScope handleScope(thread);
220
221 ASSERT(info->GetArgsNumber() == 1);
222 JSHandle<JSTaggedValue> object = GetCallArg(info, 0);
223 if (object->IsHeapObject() && object->IsJSFunction()) {
224 JSHandle<JSFunction> func = JSHandle<JSFunction>::Cast(object);
225 JSHandle<Method> method = JSHandle<Method>(thread, func->GetMethod());
226 method->SetAotCodeBit(false);
227 }
228
229 return JSTaggedValue::Undefined();
230 }
231
232 #if defined(ECMASCRIPT_SUPPORT_CPUPROFILER)
StartCpuProfiler(EcmaRuntimeCallInfo * info)233 JSTaggedValue BuiltinsArkTools::StartCpuProfiler(EcmaRuntimeCallInfo *info)
234 {
235 ASSERT(info);
236 JSThread *thread = info->GetThread();
237 [[maybe_unused]] EcmaHandleScope handleScope(thread);
238
239 auto vm = thread->GetEcmaVM();
240
241 // get file name
242 JSHandle<JSTaggedValue> fileNameValue = GetCallArg(info, 0);
243 std::string fileName = "";
244 if (fileNameValue->IsString()) {
245 JSHandle<EcmaString> str = JSTaggedValue::ToString(thread, fileNameValue);
246 RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
247 fileName = EcmaStringAccessor(str).ToStdString() + ".cpuprofile";
248 } else {
249 fileName = GetProfileName();
250 }
251
252 if (!CreateFile(fileName)) {
253 LOG_ECMA(ERROR) << "CreateFile failed " << fileName;
254 }
255
256 // get sampling interval
257 JSHandle<JSTaggedValue> samplingIntervalValue = GetCallArg(info, 1);
258 uint32_t interval = 500; // 500:Default Sampling interval 500 microseconds
259 if (samplingIntervalValue->IsNumber()) {
260 interval = JSTaggedValue::ToUint32(thread, samplingIntervalValue);
261 }
262
263 DFXJSNApi::StartCpuProfilerForFile(vm, fileName, interval);
264 return JSTaggedValue::Undefined();
265 }
266
StopCpuProfiler(EcmaRuntimeCallInfo * info)267 JSTaggedValue BuiltinsArkTools::StopCpuProfiler(EcmaRuntimeCallInfo *info)
268 {
269 JSThread *thread = info->GetThread();
270 [[maybe_unused]] EcmaHandleScope handleScope(thread);
271 auto vm = thread->GetEcmaVM();
272 DFXJSNApi::StopCpuProfilerForFile(vm);
273
274 return JSTaggedValue::Undefined();
275 }
276
GetProfileName()277 std::string BuiltinsArkTools::GetProfileName()
278 {
279 char time1[16] = {0}; // 16:Time format length
280 char time2[16] = {0}; // 16:Time format length
281 time_t timep = std::time(nullptr);
282 struct tm nowTime1;
283 localtime_r(&timep, &nowTime1);
284 size_t result = 0;
285 result = strftime(time1, sizeof(time1), "%Y%m%d", &nowTime1);
286 if (result == 0) {
287 LOG_ECMA(ERROR) << "get time failed";
288 return "";
289 }
290 result = strftime(time2, sizeof(time2), "%H%M%S", &nowTime1);
291 if (result == 0) {
292 LOG_ECMA(ERROR) << "get time failed";
293 return "";
294 }
295 std::string profileName = "cpuprofile-";
296 profileName += time1;
297 profileName += "TO";
298 profileName += time2;
299 profileName += ".cpuprofile";
300 return profileName;
301 }
302
CreateFile(std::string & fileName)303 bool BuiltinsArkTools::CreateFile(std::string &fileName)
304 {
305 std::string path = FILEDIR + fileName;
306 if (access(path.c_str(), F_OK) == 0) {
307 if (access(path.c_str(), W_OK) == 0) {
308 fileName = path;
309 return true;
310 }
311 LOG_ECMA(ERROR) << "file create failed, W_OK false";
312 return false;
313 }
314 const mode_t defaultMode = S_IRUSR | S_IWUSR | S_IRGRP; // -rw-r--
315 int fd = creat(path.c_str(), defaultMode);
316 if (fd == -1) {
317 fd = creat(fileName.c_str(), defaultMode);
318 if (fd == -1) {
319 LOG_ECMA(ERROR) << "file create failed, errno = "<< errno;
320 return false;
321 }
322 close(fd);
323 return true;
324 } else {
325 fileName = path;
326 close(fd);
327 return true;
328 }
329 }
330 #endif
331
332 // It is used to check whether an object is a proto, and this function can be
333 // used to check whether the state machine of IC is faulty.
IsPrototype(EcmaRuntimeCallInfo * info)334 JSTaggedValue BuiltinsArkTools::IsPrototype(EcmaRuntimeCallInfo *info)
335 {
336 ASSERT(info);
337 JSThread *thread = info->GetThread();
338 [[maybe_unused]] EcmaHandleScope handleScope(thread);
339
340 JSHandle<JSTaggedValue> obj = GetCallArg(info, 0);
341 JSHClass *objHclass = obj->GetTaggedObject()->GetClass();
342 return JSTaggedValue(objHclass->IsPrototype());
343 }
344
345 // It is used to check whether a function is aot compiled.
IsAOTCompiled(EcmaRuntimeCallInfo * info)346 JSTaggedValue BuiltinsArkTools::IsAOTCompiled(EcmaRuntimeCallInfo *info)
347 {
348 ASSERT(info);
349 JSThread *thread = info->GetThread();
350 [[maybe_unused]] EcmaHandleScope handleScope(thread);
351
352 JSHandle<JSTaggedValue> obj = GetCallArg(info, 0);
353 JSHandle<JSFunction> func(thread, obj.GetTaggedValue());
354 Method *method = func->GetCallTarget();
355 return JSTaggedValue(method->IsAotWithCallField());
356 }
357
IsOnHeap(EcmaRuntimeCallInfo * info)358 JSTaggedValue BuiltinsArkTools::IsOnHeap(EcmaRuntimeCallInfo *info)
359 {
360 ASSERT(info);
361 JSThread *thread = info->GetThread();
362 [[maybe_unused]] EcmaHandleScope handleScope(thread);
363
364 JSHandle<JSTaggedValue> obj = GetCallArg(info, 0);
365 return JSTaggedValue(obj.GetTaggedValue().GetTaggedObject()->GetClass()->IsOnHeapFromBitField());
366 }
367
368 // It is used to check whether a function is aot compiled and deopted at runtime.
IsAOTDeoptimized(EcmaRuntimeCallInfo * info)369 JSTaggedValue BuiltinsArkTools::IsAOTDeoptimized(EcmaRuntimeCallInfo *info)
370 {
371 ASSERT(info);
372 JSThread *thread = info->GetThread();
373 [[maybe_unused]] EcmaHandleScope handleScope(thread);
374
375 JSHandle<JSTaggedValue> obj = GetCallArg(info, 0);
376 JSHandle<JSFunction> func(thread, obj.GetTaggedValue());
377 Method *method = func->GetCallTarget();
378 bool isAotCompiled = method->IsAotWithCallField();
379 if (isAotCompiled) {
380 uint32_t deoptedCount = method->GetDeoptThreshold();
381 uint32_t deoptThreshold = thread->GetEcmaVM()->GetJSOptions().GetDeoptThreshold();
382 return JSTaggedValue(deoptedCount != deoptThreshold);
383 }
384
385 return JSTaggedValue(false);
386 }
387
PrintTypedOpProfilerAndReset(EcmaRuntimeCallInfo * info)388 JSTaggedValue BuiltinsArkTools::PrintTypedOpProfilerAndReset(EcmaRuntimeCallInfo *info)
389 {
390 ASSERT(info);
391 JSThread *thread = info->GetThread();
392 [[maybe_unused]] EcmaHandleScope handleScope(thread);
393
394 JSHandle<JSTaggedValue> opStrVal = GetCallArg(info, 0);
395 std::string opStr = EcmaStringAccessor(opStrVal.GetTaggedValue()).ToStdString();
396 TypedOpProfiler *profiler = thread->GetCurrentEcmaContext()->GetTypdOpProfiler();
397 if (profiler != nullptr) {
398 profiler->PrintAndReset(opStr);
399 }
400 return JSTaggedValue::Undefined();
401 }
402
GetElementsKind(EcmaRuntimeCallInfo * info)403 JSTaggedValue BuiltinsArkTools::GetElementsKind(EcmaRuntimeCallInfo *info)
404 {
405 ASSERT(info);
406 JSThread *thread = info->GetThread();
407 [[maybe_unused]] EcmaHandleScope handleScope(thread);
408
409 JSHandle<JSTaggedValue> obj = GetCallArg(info, 0);
410 JSHandle<JSObject> receiver(thread, obj.GetTaggedValue());
411 ElementsKind kind = receiver->GetClass()->GetElementsKind();
412 return JSTaggedValue(static_cast<uint32_t>(kind));
413 }
414
IsRegExpReplaceDetectorValid(EcmaRuntimeCallInfo * info)415 JSTaggedValue BuiltinsArkTools::IsRegExpReplaceDetectorValid(EcmaRuntimeCallInfo *info)
416 {
417 ASSERT(info);
418 JSThread *thread = info->GetThread();
419 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
420 return JSTaggedValue(PropertyDetector::IsRegExpReplaceDetectorValid(env));
421 }
422
IsSymbolIteratorDetectorValid(EcmaRuntimeCallInfo * info)423 JSTaggedValue BuiltinsArkTools::IsSymbolIteratorDetectorValid(EcmaRuntimeCallInfo *info)
424 {
425 ASSERT(info);
426 JSThread *thread = info->GetThread();
427 [[maybe_unused]] EcmaHandleScope handleScope(thread);
428
429 JSHandle<JSTaggedValue> kind = GetCallArg(info, 0);
430 if (!kind->IsString()) {
431 return JSTaggedValue::Undefined();
432 }
433 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
434 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
435 JSHandle<EcmaString> mapString = factory->NewFromUtf8("Map");
436 if (JSTaggedValue::Equal(thread, kind, JSHandle<JSTaggedValue>(mapString))) {
437 return JSTaggedValue(PropertyDetector::IsMapIteratorDetectorValid(env));
438 }
439 JSHandle<EcmaString> setString = factory->NewFromUtf8("Set");
440 if (JSTaggedValue::Equal(thread, kind, JSHandle<JSTaggedValue>(setString))) {
441 return JSTaggedValue(PropertyDetector::IsSetIteratorDetectorValid(env));
442 }
443 JSHandle<EcmaString> stringString = factory->NewFromUtf8("String");
444 if (JSTaggedValue::Equal(thread, kind, JSHandle<JSTaggedValue>(stringString))) {
445 return JSTaggedValue(PropertyDetector::IsStringIteratorDetectorValid(env));
446 }
447 JSHandle<EcmaString> arrayString = factory->NewFromUtf8("Array");
448 if (JSTaggedValue::Equal(thread, kind, JSHandle<JSTaggedValue>(arrayString))) {
449 return JSTaggedValue(PropertyDetector::IsArrayIteratorDetectorValid(env));
450 }
451 JSHandle<EcmaString> typedarrayString = factory->NewFromUtf8("TypedArray");
452 if (JSTaggedValue::Equal(thread, kind, JSHandle<JSTaggedValue>(typedarrayString))) {
453 return JSTaggedValue(PropertyDetector::IsTypedArrayIteratorDetectorValid(env));
454 }
455 return JSTaggedValue::Undefined();
456 }
457
TimeInUs(EcmaRuntimeCallInfo * info)458 JSTaggedValue BuiltinsArkTools::TimeInUs([[maybe_unused]] EcmaRuntimeCallInfo *info)
459 {
460 ClockScope scope;
461 return JSTaggedValue(scope.GetCurTime());
462 }
463 // empty function for regress-xxx test cases
PrepareFunctionForOptimization(EcmaRuntimeCallInfo * info)464 JSTaggedValue BuiltinsArkTools::PrepareFunctionForOptimization([[maybe_unused]] EcmaRuntimeCallInfo *info)
465 {
466 LOG_ECMA(DEBUG) << "Enter PrepareFunctionForOptimization()";
467 return JSTaggedValue::Undefined();
468 }
469
470 // empty function for regress-xxx test cases
OptimizeFunctionOnNextCall(EcmaRuntimeCallInfo * info)471 JSTaggedValue BuiltinsArkTools::OptimizeFunctionOnNextCall([[maybe_unused]] EcmaRuntimeCallInfo *info)
472 {
473 JSThread *thread = info->GetThread();
474 [[maybe_unused]] EcmaHandleScope handleScope(thread);
475
476 JSHandle<JSTaggedValue> thisValue = GetCallArg(info, 0);
477 if (!thisValue->IsJSFunction()) {
478 return JSTaggedValue::Undefined();
479 }
480 JSHandle<JSFunction> jsFunction(thisValue);
481 Jit::Compile(thread->GetEcmaVM(), jsFunction);
482
483 return JSTaggedValue::Undefined();
484 }
485
486 // empty function for regress-xxx test cases
OptimizeMaglevOnNextCall(EcmaRuntimeCallInfo * info)487 JSTaggedValue BuiltinsArkTools::OptimizeMaglevOnNextCall([[maybe_unused]] EcmaRuntimeCallInfo *info)
488 {
489 LOG_ECMA(DEBUG) << "Enter OptimizeMaglevOnNextCall()";
490 return JSTaggedValue::Undefined();
491 }
492
493 // empty function for regress-xxx test cases
DeoptimizeFunction(EcmaRuntimeCallInfo * info)494 JSTaggedValue BuiltinsArkTools::DeoptimizeFunction([[maybe_unused]] EcmaRuntimeCallInfo *info)
495 {
496 LOG_ECMA(DEBUG) << "Enter DeoptimizeFunction()";
497 return JSTaggedValue::Undefined();
498 }
499
500 // empty function for regress-xxx test cases
OptimizeOsr(EcmaRuntimeCallInfo * info)501 JSTaggedValue BuiltinsArkTools::OptimizeOsr([[maybe_unused]] EcmaRuntimeCallInfo *info)
502 {
503 LOG_ECMA(DEBUG) << "Enter OptimizeOsr()";
504 return JSTaggedValue::Undefined();
505 }
506
507 // empty function for regress-xxx test cases
NeverOptimizeFunction(EcmaRuntimeCallInfo * info)508 JSTaggedValue BuiltinsArkTools::NeverOptimizeFunction([[maybe_unused]] EcmaRuntimeCallInfo *info)
509 {
510 LOG_ECMA(DEBUG) << "Enter NeverOptimizeFunction()";
511 return JSTaggedValue::Undefined();
512 }
513
514 // empty function for regress-xxx test cases
HeapObjectVerify(EcmaRuntimeCallInfo * info)515 JSTaggedValue BuiltinsArkTools::HeapObjectVerify([[maybe_unused]] EcmaRuntimeCallInfo *info)
516 {
517 LOG_ECMA(DEBUG) << "Enter HeapObjectVerify()";
518 return JSTaggedValue::Undefined();
519 }
520
521 // empty function for regress-xxx test cases
DisableOptimizationFinalization(EcmaRuntimeCallInfo * info)522 JSTaggedValue BuiltinsArkTools::DisableOptimizationFinalization([[maybe_unused]] EcmaRuntimeCallInfo *info)
523 {
524 LOG_ECMA(DEBUG) << "Enter DisableOptimizationFinalization()";
525 return JSTaggedValue::Undefined();
526 }
527
528 // empty function for regress-xxx test cases
DeoptimizeNow(EcmaRuntimeCallInfo * info)529 JSTaggedValue BuiltinsArkTools::DeoptimizeNow([[maybe_unused]] EcmaRuntimeCallInfo *info)
530 {
531 LOG_ECMA(DEBUG) << "Enter DeoptimizeNow()";
532 return JSTaggedValue::Undefined();
533 }
534
535 // empty function for regress-xxx test cases
WaitForBackgroundOptimization(EcmaRuntimeCallInfo * info)536 JSTaggedValue BuiltinsArkTools::WaitForBackgroundOptimization([[maybe_unused]] EcmaRuntimeCallInfo *info)
537 {
538 LOG_ECMA(DEBUG) << "Enter WaitForBackgroundOptimization()";
539 return JSTaggedValue::Undefined();
540 }
541
542 // empty function for regress-xxx test cases
Gc(EcmaRuntimeCallInfo * info)543 JSTaggedValue BuiltinsArkTools::Gc([[maybe_unused]] EcmaRuntimeCallInfo *info)
544 {
545 LOG_ECMA(DEBUG) << "Enter Gc()";
546 return JSTaggedValue::Undefined();
547 }
548
549 // empty function for pgoAssertType
PGOAssertType(EcmaRuntimeCallInfo * info)550 JSTaggedValue BuiltinsArkTools::PGOAssertType([[maybe_unused]] EcmaRuntimeCallInfo *info)
551 {
552 LOG_ECMA(DEBUG) << "Enter PGOAssertType";
553 return JSTaggedValue::Undefined();
554 }
555
ToLength(EcmaRuntimeCallInfo * info)556 JSTaggedValue BuiltinsArkTools::ToLength([[maybe_unused]] EcmaRuntimeCallInfo *info)
557 {
558 ASSERT(info);
559 JSThread *thread = info->GetThread();
560 [[maybe_unused]] EcmaHandleScope handleScope(thread);
561 JSHandle<JSTaggedValue> key = GetCallArg(info, 0);
562 return JSTaggedValue::ToLength(thread, key);
563 }
564
HasHoleyElements(EcmaRuntimeCallInfo * info)565 JSTaggedValue BuiltinsArkTools::HasHoleyElements([[maybe_unused]] EcmaRuntimeCallInfo *info)
566 {
567 LOG_ECMA(DEBUG) << "Enter HasHoleyElements()";
568 ASSERT(info);
569 JSThread *thread = info->GetThread();
570 [[maybe_unused]] EcmaHandleScope handleScope(thread);
571 JSHandle<JSTaggedValue> array = GetCallArg(info, 0);
572 if (!array->IsJSArray()) {
573 return JSTaggedValue::False();
574 }
575 JSHandle<JSObject> obj(array);
576 uint32_t len = JSHandle<JSArray>::Cast(array)->GetArrayLength();
577 for (uint32_t i = 0; i < len; i++) {
578 if (ElementAccessor::Get(obj, i).IsHole()) {
579 return JSTaggedValue::True();
580 }
581 }
582 return JSTaggedValue::False();
583 }
584
HasDictionaryElements(EcmaRuntimeCallInfo * info)585 JSTaggedValue BuiltinsArkTools::HasDictionaryElements([[maybe_unused]] EcmaRuntimeCallInfo *info)
586 {
587 LOG_ECMA(DEBUG) << "Enter HasDictionaryElements()";
588 ASSERT(info);
589 JSThread *thread = info->GetThread();
590 [[maybe_unused]] EcmaHandleScope handleScope(thread);
591 JSHandle<JSTaggedValue> objValue = GetCallArg(info, 0);
592 JSHandle<JSObject> obj = JSHandle<JSObject>::Cast(objValue);
593 return JSTaggedValue(obj->GetJSHClass()->IsDictionaryMode());
594 }
595
HasSmiElements(EcmaRuntimeCallInfo * info)596 JSTaggedValue BuiltinsArkTools::HasSmiElements([[maybe_unused]] EcmaRuntimeCallInfo *info)
597 {
598 LOG_ECMA(DEBUG) << "Enter HasSmiElements()";
599 ASSERT(info);
600 JSThread *thread = info->GetThread();
601 [[maybe_unused]] EcmaHandleScope handleScope(thread);
602 JSHandle<JSTaggedValue> array = GetCallArg(info, 0);
603 if (!array->IsJSArray()) {
604 return JSTaggedValue::False();
605 }
606 JSHandle<JSObject> obj(array);
607 uint32_t len = JSHandle<JSArray>::Cast(array)->GetArrayLength();
608 for (uint32_t i = 0; i < len; i++) {
609 if (ElementAccessor::Get(obj, i).IsInt()) {
610 return JSTaggedValue::True();
611 }
612 }
613 return JSTaggedValue::False();
614 }
615
HasDoubleElements(EcmaRuntimeCallInfo * info)616 JSTaggedValue BuiltinsArkTools::HasDoubleElements([[maybe_unused]] EcmaRuntimeCallInfo *info)
617 {
618 LOG_ECMA(DEBUG) << "Enter HasDoubleElements()";
619 ASSERT(info);
620 JSThread *thread = info->GetThread();
621 [[maybe_unused]] EcmaHandleScope handleScope(thread);
622 JSHandle<JSTaggedValue> array = GetCallArg(info, 0);
623 if (!array->IsJSArray()) {
624 return JSTaggedValue::False();
625 }
626 JSHandle<JSObject> obj(array);
627 uint32_t len = JSHandle<JSArray>::Cast(array)->GetArrayLength();
628 for (uint32_t i = 0; i < len; i++) {
629 if (ElementAccessor::Get(obj, i).IsDouble() && !ElementAccessor::Get(obj, i).IsZero()) {
630 return JSTaggedValue::True();
631 }
632 }
633 return JSTaggedValue::False();
634 }
635
HasObjectElements(EcmaRuntimeCallInfo * info)636 JSTaggedValue BuiltinsArkTools::HasObjectElements([[maybe_unused]] EcmaRuntimeCallInfo *info)
637 {
638 LOG_ECMA(DEBUG) << "Enter HasObjectElements()";
639 ASSERT(info);
640 JSThread *thread = info->GetThread();
641 [[maybe_unused]] EcmaHandleScope handleScope(thread);
642 JSHandle<JSTaggedValue> array = GetCallArg(info, 0);
643 if (!array->IsJSArray()) {
644 return JSTaggedValue::False();
645 }
646 JSHandle<JSObject> obj(array);
647 uint32_t len = JSHandle<JSArray>::Cast(array)->GetArrayLength();
648 for (uint32_t i = 0; i < len; i++) {
649 if (ElementAccessor::Get(obj, i).IsObject()) {
650 return JSTaggedValue::True();
651 }
652 }
653 return JSTaggedValue::False();
654 }
655
ArrayBufferDetach(EcmaRuntimeCallInfo * info)656 JSTaggedValue BuiltinsArkTools::ArrayBufferDetach([[maybe_unused]] EcmaRuntimeCallInfo *info)
657 {
658 ASSERT(info);
659 JSThread *thread = info->GetThread();
660 [[maybe_unused]] EcmaHandleScope handleScope(thread);
661 JSHandle<JSTaggedValue> obj1 = GetCallArg(info, 0);
662 JSHandle<JSArrayBuffer> arrBuf = JSHandle<JSArrayBuffer>::Cast(obj1);
663 arrBuf->Detach(thread);
664 return JSTaggedValue::Undefined();
665 }
666
HaveSameMap(EcmaRuntimeCallInfo * info)667 JSTaggedValue BuiltinsArkTools::HaveSameMap([[maybe_unused]] EcmaRuntimeCallInfo *info)
668 {
669 JSThread *thread = info->GetThread();
670 [[maybe_unused]] EcmaHandleScope handleScope(thread);
671 JSHandle<JSTaggedValue> obj1 = GetCallArg(info, 0);
672 JSHandle<JSTaggedValue> obj2 = GetCallArg(info, 1);
673 JSHandle<TaggedArray> keys1 = JSTaggedValue::GetOwnPropertyKeys(thread, obj1);
674 JSHandle<TaggedArray> keys2 = JSTaggedValue::GetOwnPropertyKeys(thread, obj2);
675 RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
676 uint32_t len = keys1->GetLength();
677 if (len != keys2->GetLength()) {
678 return JSTaggedValue::False();
679 }
680 JSMutableHandle<JSTaggedValue> keyHandle(thread, JSTaggedValue::Undefined());
681 for (uint32_t i = 0; i < len; i++) {
682 if (keys1->Get(i) != keys2->Get(i)) {
683 return JSTaggedValue::False();
684 }
685 keyHandle.Update(keys1->Get(i));
686 OperationResult result = JSObject::GetProperty(thread, obj1, keyHandle);
687 RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
688 JSTaggedValue value1 = result.GetValue().GetTaggedValue();
689 result = JSObject::GetProperty(thread, obj2, keyHandle);
690 RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
691 JSTaggedValue value2 = result.GetValue().GetTaggedValue();
692 if (FastRuntimeStub::FastTypeOf(thread, value1) !=
693 FastRuntimeStub::FastTypeOf(thread, value2)) {
694 return JSTaggedValue::False();
695 }
696 }
697 return JSTaggedValue::True();
698 }
699
CreatePrivateSymbol(EcmaRuntimeCallInfo * info)700 JSTaggedValue BuiltinsArkTools::CreatePrivateSymbol([[maybe_unused]] EcmaRuntimeCallInfo *info)
701 {
702 ASSERT(info);
703 JSThread *thread = info->GetThread();
704 [[maybe_unused]] EcmaHandleScope handleScope(thread);
705 JSHandle<JSTaggedValue> symbolName = GetCallArg(info, 0);
706 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
707 JSHandle<JSSymbol> privateNameSymbol = factory->NewPrivateNameSymbol(symbolName);
708 JSHandle<JSTaggedValue> symbolValue = JSHandle<JSTaggedValue>::Cast(privateNameSymbol);
709 return symbolValue.GetTaggedValue();
710 }
711
IsArray(EcmaRuntimeCallInfo * info)712 JSTaggedValue BuiltinsArkTools::IsArray([[maybe_unused]] EcmaRuntimeCallInfo *info)
713 {
714 ASSERT(info);
715 JSThread *thread = info->GetThread();
716 [[maybe_unused]] EcmaHandleScope handleScope(thread);
717 JSHandle<JSTaggedValue> array = GetCallArg(info, 0);
718 return JSTaggedValue(array->IsJSArray());
719 }
720
CreateDataProperty(EcmaRuntimeCallInfo * info)721 JSTaggedValue BuiltinsArkTools::CreateDataProperty([[maybe_unused]] EcmaRuntimeCallInfo *info)
722 {
723 ASSERT(info);
724 JSThread *thread = info->GetThread();
725 uint32_t secondArg = 2;
726 [[maybe_unused]] EcmaHandleScope handleScope(thread);
727 JSHandle<JSTaggedValue> key = GetCallArg(info, 1);
728 JSHandle<JSTaggedValue> value = GetCallArg(info, secondArg);
729 JSHandle<JSObject> obj = JSHandle<JSObject>::Cast(GetCallArg(info, 0));
730 JSObject::CreateDataPropertyOrThrow(thread, obj, key, value);
731 return value.GetTaggedValue();
732 }
733
FunctionGetInferredName(EcmaRuntimeCallInfo * info)734 JSTaggedValue BuiltinsArkTools::FunctionGetInferredName([[maybe_unused]] EcmaRuntimeCallInfo *info)
735 {
736 ASSERT(info);
737 JSThread *thread = info->GetThread();
738 [[maybe_unused]] EcmaHandleScope handleScope(thread);
739 JSHandle<JSTaggedValue> obj = GetCallArg(info, 0);
740 if (obj->IsJSFunction()) {
741 JSHandle<JSFunction> funcObj = JSHandle<JSFunction>::Cast(obj);
742 JSHandle<JSTaggedValue> funcName = JSFunction::GetFunctionName(thread, JSHandle<JSFunctionBase>(funcObj));
743 return funcName.GetTaggedValue();
744 }
745 return thread->GlobalConstants()->GetHandledEmptyString().GetTaggedValue();
746 }
747
StringLessThan(EcmaRuntimeCallInfo * info)748 JSTaggedValue BuiltinsArkTools::StringLessThan([[maybe_unused]] EcmaRuntimeCallInfo *info)
749 {
750 ASSERT(info);
751 JSThread *thread = info->GetThread();
752 [[maybe_unused]] EcmaHandleScope handleScope(thread);
753 JSHandle<JSTaggedValue> x = GetCallArg(info, 0);
754 JSHandle<JSTaggedValue> y = GetCallArg(info, 1);
755 ComparisonResult result = JSTaggedValue::Compare(thread, x, y);
756 return JSTaggedValue(ComparisonResult::LESS == result);
757 }
758
StringMaxLength(EcmaRuntimeCallInfo * info)759 JSTaggedValue BuiltinsArkTools::StringMaxLength([[maybe_unused]] EcmaRuntimeCallInfo *info)
760 {
761 LOG_ECMA(DEBUG) << "Enter StringMaxLength()";
762 ASSERT(info);
763 return JSTaggedValue(static_cast<uint32_t>(EcmaString::MAX_STRING_LENGTH) - 1);
764 }
765
ArrayBufferMaxByteLength(EcmaRuntimeCallInfo * info)766 JSTaggedValue BuiltinsArkTools::ArrayBufferMaxByteLength([[maybe_unused]] EcmaRuntimeCallInfo *info)
767 {
768 LOG_ECMA(DEBUG) << "Enter ArrayBufferMaxByteLength()";
769 ASSERT(info);
770 return JSTaggedValue(INT_MAX);
771 }
772
TypedArrayMaxLength(EcmaRuntimeCallInfo * info)773 JSTaggedValue BuiltinsArkTools::TypedArrayMaxLength([[maybe_unused]] EcmaRuntimeCallInfo *info)
774 {
775 LOG_ECMA(DEBUG) << "Enter TypedArrayMaxLength()";
776 ASSERT(info);
777 return JSTaggedValue(BuiltinsTypedArray::MAX_ARRAY_INDEX);
778 }
779
MaxSmi(EcmaRuntimeCallInfo * info)780 JSTaggedValue BuiltinsArkTools::MaxSmi([[maybe_unused]] EcmaRuntimeCallInfo *info)
781 {
782 LOG_ECMA(DEBUG) << "Enter MaxSmi()";
783 return JSTaggedValue(INT_MAX);
784 }
785
Is64Bit(EcmaRuntimeCallInfo * info)786 JSTaggedValue BuiltinsArkTools::Is64Bit([[maybe_unused]] EcmaRuntimeCallInfo *info)
787 {
788 LOG_ECMA(DEBUG) << "Enter Is64Bit()";
789 bool is64Bit = sizeof(void*) == 8;
790 return JSTaggedValue(is64Bit);
791 }
792
793 // empty function for regress-xxx test cases
FinalizeOptimization(EcmaRuntimeCallInfo * info)794 JSTaggedValue BuiltinsArkTools::FinalizeOptimization([[maybe_unused]] EcmaRuntimeCallInfo *info)
795 {
796 LOG_ECMA(DEBUG) << "Enter FinalizeOptimization()";
797 return JSTaggedValue::Undefined();
798 }
799
800 // empty function for regress-xxx test cases
EnsureFeedbackVectorForFunction(EcmaRuntimeCallInfo * info)801 JSTaggedValue BuiltinsArkTools::EnsureFeedbackVectorForFunction([[maybe_unused]] EcmaRuntimeCallInfo *info)
802 {
803 LOG_ECMA(DEBUG) << "Enter EnsureFeedbackVectorForFunction()";
804 return JSTaggedValue::Undefined();
805 }
806
807 // empty function for regress-xxx test cases
CompileBaseline(EcmaRuntimeCallInfo * info)808 JSTaggedValue BuiltinsArkTools::CompileBaseline([[maybe_unused]] EcmaRuntimeCallInfo *info)
809 {
810 LOG_ECMA(DEBUG) << "Enter CompileBaseline()";
811 return JSTaggedValue::Undefined();
812 }
813
814 // empty function for regress-xxx test cases
DebugGetLoadedScriptIds(EcmaRuntimeCallInfo * info)815 JSTaggedValue BuiltinsArkTools::DebugGetLoadedScriptIds([[maybe_unused]] EcmaRuntimeCallInfo *info)
816 {
817 LOG_ECMA(DEBUG) << "Enter DebugGetLoadedScriptIds()";
818 return JSTaggedValue::Undefined();
819 }
820
821 // empty function for regress-xxx test cases
ToFastProperties(EcmaRuntimeCallInfo * info)822 JSTaggedValue BuiltinsArkTools::ToFastProperties([[maybe_unused]] EcmaRuntimeCallInfo *info)
823 {
824 LOG_ECMA(DEBUG) << "Enter ToFastProperties()";
825 return JSTaggedValue::Undefined();
826 }
827
AbortJS(EcmaRuntimeCallInfo * info)828 JSTaggedValue BuiltinsArkTools::AbortJS([[maybe_unused]] EcmaRuntimeCallInfo *info)
829 {
830 LOG_ECMA(FATAL) << "AbortJS()";
831 ASSERT(info);
832 return JSTaggedValue::Undefined();
833 }
834
835 // empty function for regress-xxx test cases
InternalizeString(EcmaRuntimeCallInfo * info)836 JSTaggedValue BuiltinsArkTools::InternalizeString([[maybe_unused]] EcmaRuntimeCallInfo *info)
837 {
838 LOG_ECMA(DEBUG) << "Enter InternalizeString()";
839 ASSERT(info);
840 return JSTaggedValue::Undefined();
841 }
842
843 // empty function for regress-xxx test cases
HandleDebuggerStatement(EcmaRuntimeCallInfo * info)844 JSTaggedValue BuiltinsArkTools::HandleDebuggerStatement([[maybe_unused]] EcmaRuntimeCallInfo *info)
845 {
846 LOG_ECMA(DEBUG) << "Enter HandleDebuggerStatement()";
847 ASSERT(info);
848 return JSTaggedValue::Undefined();
849 }
850
851 // empty function for regress-xxx test cases
SetAllocationTimeout(EcmaRuntimeCallInfo * info)852 JSTaggedValue BuiltinsArkTools::SetAllocationTimeout([[maybe_unused]] EcmaRuntimeCallInfo *info)
853 {
854 LOG_ECMA(DEBUG) << "Enter SetAllocationTimeout()";
855 ASSERT(info);
856 return JSTaggedValue::Undefined();
857 }
858
859 // empty function for regress-xxx test cases
HasFastProperties(EcmaRuntimeCallInfo * info)860 JSTaggedValue BuiltinsArkTools::HasFastProperties([[maybe_unused]] EcmaRuntimeCallInfo *info)
861 {
862 LOG_ECMA(DEBUG) << "Enter HasFastProperties()";
863 ASSERT(info);
864 return JSTaggedValue::True();
865 }
866
867 // empty function for regress-xxx test cases
HasOwnConstDataProperty(EcmaRuntimeCallInfo * info)868 JSTaggedValue BuiltinsArkTools::HasOwnConstDataProperty([[maybe_unused]] EcmaRuntimeCallInfo *info)
869 {
870 LOG_ECMA(DEBUG) << "Enter HasOwnConstDataProperty()";
871 ASSERT(info);
872 return JSTaggedValue::True();
873 }
874
875 // empty function for regress-xxx test cases
GetHoleNaNUpper(EcmaRuntimeCallInfo * info)876 JSTaggedValue BuiltinsArkTools::GetHoleNaNUpper([[maybe_unused]] EcmaRuntimeCallInfo *info)
877 {
878 LOG_ECMA(DEBUG) << "Enter GetHoleNaNUpper()";
879 ASSERT(info);
880 return JSTaggedValue::Null();
881 }
882
883 // empty function for regress-xxx test cases
GetHoleNaNLower(EcmaRuntimeCallInfo * info)884 JSTaggedValue BuiltinsArkTools::GetHoleNaNLower([[maybe_unused]] EcmaRuntimeCallInfo *info)
885 {
886 LOG_ECMA(DEBUG) << "Enter GetHoleNaNLower()";
887 ASSERT(info);
888 return JSTaggedValue::Null();
889 }
890
891 // empty function for regress-xxx test cases
SystemBreak(EcmaRuntimeCallInfo * info)892 JSTaggedValue BuiltinsArkTools::SystemBreak([[maybe_unused]] EcmaRuntimeCallInfo *info)
893 {
894 LOG_ECMA(DEBUG) << "Enter SystemBreak()";
895 ASSERT(info);
896 return JSTaggedValue::Undefined();
897 }
898
899 // empty function for regress-xxx test cases
ScheduleBreak(EcmaRuntimeCallInfo * info)900 JSTaggedValue BuiltinsArkTools::ScheduleBreak([[maybe_unused]] EcmaRuntimeCallInfo *info)
901 {
902 LOG_ECMA(DEBUG) << "Enter ScheduleBreak()";
903 ASSERT(info);
904 return JSTaggedValue::Undefined();
905 }
906
907 // empty function for regress-xxx test cases
EnqueueMicrotask(EcmaRuntimeCallInfo * info)908 JSTaggedValue BuiltinsArkTools::EnqueueMicrotask([[maybe_unused]] EcmaRuntimeCallInfo *info)
909 {
910 LOG_ECMA(DEBUG) << "Enter EnqueueMicrotask()";
911 ASSERT(info);
912 return JSTaggedValue::Undefined();
913 }
914
915 // empty function for regress-xxx test cases
DebugPrint(EcmaRuntimeCallInfo * info)916 JSTaggedValue BuiltinsArkTools::DebugPrint([[maybe_unused]] EcmaRuntimeCallInfo *info)
917 {
918 LOG_ECMA(DEBUG) << "Enter DebugPrint()";
919 ASSERT(info);
920 return JSTaggedValue::Undefined();
921 }
922
923 // empty function for regress-xxx test cases
GetOptimizationStatus(EcmaRuntimeCallInfo * info)924 JSTaggedValue BuiltinsArkTools::GetOptimizationStatus([[maybe_unused]] EcmaRuntimeCallInfo *info)
925 {
926 LOG_ECMA(DEBUG) << "Enter GetOptimizationStatus()";
927 ASSERT(info);
928 return JSTaggedValue::Undefined();
929 }
930
931 // empty function for regress-xxx test cases
GetUndetectable(EcmaRuntimeCallInfo * info)932 JSTaggedValue BuiltinsArkTools::GetUndetectable([[maybe_unused]] EcmaRuntimeCallInfo *info)
933 {
934 LOG_ECMA(DEBUG) << "Enter GetUndetectable()";
935 ASSERT(info);
936 return JSTaggedValue::Undefined();
937 }
938
939 // empty function for regress-xxx test cases
SetKeyedProperty(EcmaRuntimeCallInfo * info)940 JSTaggedValue BuiltinsArkTools::SetKeyedProperty([[maybe_unused]] EcmaRuntimeCallInfo *info)
941 {
942 LOG_ECMA(DEBUG) << "Enter SetKeyedProperty()";
943 ASSERT(info);
944 return JSTaggedValue::Undefined();
945 }
946
947 // empty function for regress-xxx test cases
DisassembleFunction(EcmaRuntimeCallInfo * info)948 JSTaggedValue BuiltinsArkTools::DisassembleFunction([[maybe_unused]] EcmaRuntimeCallInfo *info)
949 {
950 LOG_ECMA(DEBUG) << "Enter DisassembleFunction()";
951 ASSERT(info);
952 return JSTaggedValue::Undefined();
953 }
954
955 // empty function for regress-xxx test cases
TryMigrateInstance(EcmaRuntimeCallInfo * info)956 JSTaggedValue BuiltinsArkTools::TryMigrateInstance([[maybe_unused]] EcmaRuntimeCallInfo *info)
957 {
958 LOG_ECMA(DEBUG) << "Enter TryMigrateInstance()";
959 ASSERT(info);
960 return JSTaggedValue::Undefined();
961 }
962
963 // empty function for regress-xxx test cases
InLargeObjectSpace(EcmaRuntimeCallInfo * info)964 JSTaggedValue BuiltinsArkTools::InLargeObjectSpace([[maybe_unused]] EcmaRuntimeCallInfo *info)
965 {
966 LOG_ECMA(DEBUG) << "Enter InLargeObjectSpace()";
967 ASSERT(info);
968 return JSTaggedValue::True();
969 }
970
971 // empty function for regress-xxx test cases
PerformMicrotaskCheckpoint(EcmaRuntimeCallInfo * info)972 JSTaggedValue BuiltinsArkTools::PerformMicrotaskCheckpoint([[maybe_unused]] EcmaRuntimeCallInfo *info)
973 {
974 LOG_ECMA(DEBUG) << "Enter PerformMicrotaskCheckpoint()";
975 ASSERT(info);
976 return JSTaggedValue::Undefined();
977 }
978
979 // empty function for regress-xxx test cases
IsJSReceiver(EcmaRuntimeCallInfo * info)980 JSTaggedValue BuiltinsArkTools::IsJSReceiver([[maybe_unused]] EcmaRuntimeCallInfo *info)
981 {
982 LOG_ECMA(DEBUG) << "Enter IsJSReceiver()";
983 ASSERT(info);
984 return JSTaggedValue::False();
985 }
986
987 // empty function for regress-xxx test cases
IsDictPropertyConstTrackingEnabled(EcmaRuntimeCallInfo * info)988 JSTaggedValue BuiltinsArkTools::IsDictPropertyConstTrackingEnabled([[maybe_unused]] EcmaRuntimeCallInfo *info)
989 {
990 LOG_ECMA(DEBUG) << "Enter IsDictPropertyConstTrackingEnabled()";
991 ASSERT(info);
992 return JSTaggedValue::False();
993 }
994
995 // empty function for regress-xxx test cases
AllocateHeapNumber(EcmaRuntimeCallInfo * info)996 JSTaggedValue BuiltinsArkTools::AllocateHeapNumber([[maybe_unused]] EcmaRuntimeCallInfo *info)
997 {
998 LOG_ECMA(DEBUG) << "Enter AllocateHeapNumber()";
999 ASSERT(info);
1000 return JSTaggedValue(0);
1001 }
1002
1003 // empty function for regress-xxx test cases
ConstructConsString(EcmaRuntimeCallInfo * info)1004 JSTaggedValue BuiltinsArkTools::ConstructConsString([[maybe_unused]] EcmaRuntimeCallInfo *info)
1005 {
1006 LOG_ECMA(DEBUG) << "Enter ConstructConsString()";
1007 ASSERT(info);
1008 return JSTaggedValue::Undefined();
1009 }
1010
1011 // empty function for regress-xxx test cases
CompleteInobjectSlackTracking(EcmaRuntimeCallInfo * info)1012 JSTaggedValue BuiltinsArkTools::CompleteInobjectSlackTracking([[maybe_unused]] EcmaRuntimeCallInfo *info)
1013 {
1014 LOG_ECMA(DEBUG) << "Enter CompleteInobjectSlackTracking()";
1015 ASSERT(info);
1016 return JSTaggedValue::Undefined();
1017 }
1018
1019 // empty function for regress-xxx test cases
NormalizeElements(EcmaRuntimeCallInfo * info)1020 JSTaggedValue BuiltinsArkTools::NormalizeElements([[maybe_unused]] EcmaRuntimeCallInfo *info)
1021 {
1022 LOG_ECMA(DEBUG) << "Enter NormalizeElements()";
1023 ASSERT(info);
1024 return JSTaggedValue::Undefined();
1025 }
1026
1027 // empty function for regress-xxx test cases
Call(EcmaRuntimeCallInfo * info)1028 JSTaggedValue BuiltinsArkTools::Call([[maybe_unused]] EcmaRuntimeCallInfo *info)
1029 {
1030 LOG_ECMA(DEBUG) << "Enter Call()";
1031 ASSERT(info);
1032 return JSTaggedValue::Undefined();
1033 }
1034
1035 // empty function for regress-xxx test cases
DebugPushPromise(EcmaRuntimeCallInfo * info)1036 JSTaggedValue BuiltinsArkTools::DebugPushPromise([[maybe_unused]] EcmaRuntimeCallInfo *info)
1037 {
1038 LOG_ECMA(DEBUG) << "Enter DebugPushPromise()";
1039 ASSERT(info);
1040 return JSTaggedValue::Undefined();
1041 }
1042
1043 // empty function for regress-xxx test cases
SetForceSlowPath(EcmaRuntimeCallInfo * info)1044 JSTaggedValue BuiltinsArkTools::SetForceSlowPath([[maybe_unused]] EcmaRuntimeCallInfo *info)
1045 {
1046 LOG_ECMA(DEBUG) << "Enter SetForceSlowPath()";
1047 ASSERT(info);
1048 return JSTaggedValue::Undefined();
1049 }
1050
1051 // empty function for regress-xxx test cases
NotifyContextDisposed(EcmaRuntimeCallInfo * info)1052 JSTaggedValue BuiltinsArkTools::NotifyContextDisposed([[maybe_unused]] EcmaRuntimeCallInfo *info)
1053 {
1054 LOG_ECMA(DEBUG) << "Enter NotifyContextDisposed()";
1055 ASSERT(info);
1056 return JSTaggedValue::Undefined();
1057 }
1058
1059 // empty function for regress-xxx test cases
OptimizeObjectForAddingMultipleProperties(EcmaRuntimeCallInfo * info)1060 JSTaggedValue BuiltinsArkTools::OptimizeObjectForAddingMultipleProperties([[maybe_unused]] EcmaRuntimeCallInfo *info)
1061 {
1062 LOG_ECMA(DEBUG) << "Enter OptimizeObjectForAddingMultipleProperties()";
1063 ASSERT(info);
1064 return JSTaggedValue::Undefined();
1065 }
1066
1067 // empty function for regress-xxx test cases
IsBeingInterpreted(EcmaRuntimeCallInfo * info)1068 JSTaggedValue BuiltinsArkTools::IsBeingInterpreted([[maybe_unused]] EcmaRuntimeCallInfo *info)
1069 {
1070 LOG_ECMA(DEBUG) << "Enter OptimizeObjectForAddingMultipleProperties()";
1071 ASSERT(info);
1072 return JSTaggedValue::Undefined();
1073 }
1074
1075 // empty function for regress-xxx test cases
ClearFunctionFeedback(EcmaRuntimeCallInfo * info)1076 JSTaggedValue BuiltinsArkTools::ClearFunctionFeedback([[maybe_unused]] EcmaRuntimeCallInfo *info)
1077 {
1078 LOG_ECMA(DEBUG) << "Enter ClearFunctionFeedback()";
1079 return JSTaggedValue::Undefined();
1080 }
1081 } // namespace panda::ecmascript::builtins
1082