1 /*
2 * Copyright (c) 2021-2024 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/jspandafile/panda_file_translator.h"
17
18 #include "ecmascript/compiler/bytecodes.h"
19 #include "ecmascript/interpreter/slow_runtime_stub.h"
20 #include "ecmascript/patch/quick_fix_helper.h"
21
22 namespace panda::ecmascript {
23 using EcmaOpcode = kungfu::EcmaOpcode;
24
25 template<class T, class... Args>
InitializeMemory(T *mem, Args... args)26 static T *InitializeMemory(T *mem, Args... args)
27 {
28 return new (mem) T(std::forward<Args>(args)...);
29 }
30
TranslateClasses(const JSThread *thread, JSPandaFile *jsPandaFile, const CString &methodName)31 void PandaFileTranslator::TranslateClasses(const JSThread *thread, JSPandaFile *jsPandaFile, const CString &methodName)
32 {
33 ASSERT(jsPandaFile != nullptr && jsPandaFile->GetMethodLiterals() != nullptr);
34 MethodLiteral *methodLiterals = jsPandaFile->GetMethodLiterals();
35 const panda_file::File *pf = jsPandaFile->GetPandaFile();
36 size_t methodIdx = 0;
37 std::set<const uint8_t *> translatedCode;
38 Span<const uint32_t> classIndexes = jsPandaFile->GetClasses();
39 for (const uint32_t index : classIndexes) {
40 panda_file::File::EntityId classId(index);
41 if (jsPandaFile->IsExternal(classId)) {
42 continue;
43 }
44 panda_file::ClassDataAccessor cda(*pf, classId);
45 CString recordName = JSPandaFile::ParseEntryPoint(utf::Mutf8AsCString(cda.GetDescriptor()));
46 bool isUpdateMainMethodIndex = false;
47 cda.EnumerateMethods([thread, jsPandaFile, &translatedCode, methodLiterals, &methodIdx, pf, &methodName,
48 &recordName, &isUpdateMainMethodIndex]
49 (panda_file::MethodDataAccessor &mda) {
50 auto methodId = mda.GetMethodId();
51 CString name = reinterpret_cast<const char *>(jsPandaFile->GetStringData(mda.GetNameId()).data);
52 auto methodOffset = methodId.GetOffset();
53 if (jsPandaFile->IsBundlePack()) {
54 if (!isUpdateMainMethodIndex && name == methodName) {
55 jsPandaFile->UpdateMainMethodIndex(methodOffset);
56 isUpdateMainMethodIndex = true;
57 }
58 } else {
59 if (!isUpdateMainMethodIndex && JSPandaFile::IsEntryOrPatch(name)) {
60 jsPandaFile->UpdateMainMethodIndex(methodOffset, recordName);
61 isUpdateMainMethodIndex = true;
62 }
63 }
64
65 MethodLiteral *methodLiteral = methodLiterals + (methodIdx++);
66 InitializeMemory(methodLiteral, methodId);
67 methodLiteral->Initialize(jsPandaFile, thread);
68
69 if (jsPandaFile->IsNewVersion()) {
70 panda_file::IndexAccessor indexAccessor(*pf, methodId);
71 panda_file::FunctionKind funcKind = indexAccessor.GetFunctionKind();
72 bool isShared = JSPandaFile::IsSendableFunctionKind(funcKind);
73 methodLiteral->SetIsShared(isShared);
74 FunctionKind kind = JSPandaFile::GetFunctionKind(funcKind);
75 methodLiteral->SetFunctionKind(kind);
76 } else {
77 auto codeId = mda.GetCodeId();
78 ASSERT(codeId.has_value());
79 panda_file::CodeDataAccessor codeDataAccessor(*pf, codeId.value());
80 uint32_t codeSize = codeDataAccessor.GetCodeSize();
81 const uint8_t *insns = codeDataAccessor.GetInstructions();
82 if (translatedCode.find(insns) == translatedCode.end()) {
83 translatedCode.insert(insns);
84 if (jsPandaFile->IsBundlePack()) {
85 TranslateBytecode(jsPandaFile, codeSize, insns, methodLiteral);
86 } else {
87 TranslateBytecode(jsPandaFile, codeSize, insns, methodLiteral, recordName);
88 }
89 }
90 }
91 jsPandaFile->SetMethodLiteralToMap(methodLiteral);
92 });
93 }
94 }
95
TranslateClass(const JSThread *thread, JSPandaFile *jsPandaFile, const CString &methodName, size_t methodIdx, size_t classIdx)96 void PandaFileTranslator::TranslateClass(const JSThread *thread, JSPandaFile *jsPandaFile,
97 const CString &methodName, size_t methodIdx, size_t classIdx)
98 {
99 ASSERT(jsPandaFile != nullptr && jsPandaFile->GetMethodLiterals() != nullptr);
100 MethodLiteral *methodLiterals = jsPandaFile->GetMethodLiterals();
101 const panda_file::File *pf = jsPandaFile->GetPandaFile();
102 Span<const uint32_t> classIndexes = jsPandaFile->GetClasses();
103 const uint32_t index = classIndexes[classIdx];
104 panda_file::File::EntityId classId(index);
105 panda_file::ClassDataAccessor cda(*pf, classId);
106 CString recordName = JSPandaFile::ParseEntryPoint(utf::Mutf8AsCString(cda.GetDescriptor()));
107 bool isUpdateMainMethodIndex = false;
108 cda.EnumerateMethods([thread, jsPandaFile, methodLiterals, &methodIdx, pf, &methodName,
109 &recordName, &isUpdateMainMethodIndex]
110 (panda_file::MethodDataAccessor &mda) {
111 auto methodId = mda.GetMethodId();
112 CString name = reinterpret_cast<const char *>(jsPandaFile->GetStringData(mda.GetNameId()).data);
113 auto methodOffset = methodId.GetOffset();
114 if (jsPandaFile->IsBundlePack()) {
115 if (!isUpdateMainMethodIndex && name == methodName) {
116 jsPandaFile->UpdateMainMethodIndex(methodOffset);
117 isUpdateMainMethodIndex = true;
118 }
119 } else {
120 if (!isUpdateMainMethodIndex && JSPandaFile::IsEntryOrPatch(name)) {
121 jsPandaFile->UpdateMainMethodIndex(methodOffset, recordName);
122 isUpdateMainMethodIndex = true;
123 }
124 }
125
126 MethodLiteral *methodLiteral = methodLiterals + (methodIdx++);
127 InitializeMemory(methodLiteral, methodId);
128 methodLiteral->Initialize(jsPandaFile, thread);
129 // IsNewVersion
130 panda_file::IndexAccessor indexAccessor(*pf, methodId);
131 panda_file::FunctionKind funcKind = indexAccessor.GetFunctionKind();
132 bool isShared = JSPandaFile::IsSendableFunctionKind(funcKind);
133 methodLiteral->SetIsShared(isShared);
134 FunctionKind kind = JSPandaFile::GetFunctionKind(funcKind);
135 methodLiteral->SetFunctionKind(kind);
136 });
137 }
138
GenerateProgram(EcmaVM *vm, const JSPandaFile *jsPandaFile, std::string_view entryPoint)139 JSHandle<Program> PandaFileTranslator::GenerateProgram(EcmaVM *vm, const JSPandaFile *jsPandaFile,
140 std::string_view entryPoint)
141 {
142 bool isNewVersion = jsPandaFile->IsNewVersion();
143 uint32_t mainMethodIndex = jsPandaFile->GetMainMethodIndex(entryPoint.data(), isNewVersion);
144 JSHandle<ConstantPool> sconstpool;
145 if (isNewVersion) {
146 sconstpool = vm->GetJSThread()->GetCurrentEcmaContext()->FindOrCreateConstPool(
147 jsPandaFile, EntityId(mainMethodIndex));
148 } else {
149 EcmaContext *context = vm->GetJSThread()->GetCurrentEcmaContext();
150 JSTaggedValue constpoolVal = context->FindConstpool(jsPandaFile, 0);
151 JSHandle<ConstantPool> unsharedConstpool;
152 if (constpoolVal.IsHole()) {
153 std::pair<JSHandle<ConstantPool>, JSHandle<ConstantPool>> constpoolPair = ParseConstPool(vm, jsPandaFile);
154 sconstpool = constpoolPair.first;
155 unsharedConstpool = constpoolPair.second;
156 // old version dont support multi constpool
157 sconstpool = context->AddOrUpdateConstpool(jsPandaFile, sconstpool);
158 context->SetUnsharedConstpool(sconstpool, unsharedConstpool.GetTaggedValue());
159 } else {
160 sconstpool = JSHandle<ConstantPool>(vm->GetJSThread(), constpoolVal);
161 unsharedConstpool = JSHandle<ConstantPool>(
162 vm->GetJSThread(), context->FindOrCreateUnsharedConstpool(sconstpool.GetTaggedValue()));
163 }
164
165 if (!jsPandaFile->IsBundlePack()) {
166 ParseFuncAndLiteralConstPool(vm, jsPandaFile, entryPoint.data(), sconstpool, unsharedConstpool);
167 }
168 }
169
170 MethodLiteral *mainMethodLiteral = jsPandaFile->FindMethodLiteral(mainMethodIndex);
171 return GenerateProgramInternal(vm, mainMethodLiteral, sconstpool, jsPandaFile);
172 }
173
GenerateProgramInternal(EcmaVM *vm, MethodLiteral *mainMethodLiteral, JSHandle<ConstantPool> constpool, const JSPandaFile *jsPandaFile)174 JSHandle<Program> PandaFileTranslator::GenerateProgramInternal(EcmaVM *vm,
175 MethodLiteral *mainMethodLiteral,
176 JSHandle<ConstantPool> constpool,
177 const JSPandaFile *jsPandaFile)
178 {
179 JSThread *thread = vm->GetJSThread();
180 ObjectFactory *factory = vm->GetFactory();
181 JSHandle<Program> program = factory->NewProgram();
182
183 [[maybe_unused]] EcmaHandleScope handleScope(thread);
184 if (mainMethodLiteral == nullptr) {
185 program->SetMainFunction(thread, JSTaggedValue::Undefined());
186 } else {
187 JSHandle<GlobalEnv> env = vm->GetGlobalEnv();
188 JSHandle<Method> method = factory->NewSMethod(mainMethodLiteral);
189 JSTaggedValue patchVal = QuickFixHelper::CreateMainFuncWithPatch(vm, mainMethodLiteral, jsPandaFile);
190 if (!patchVal.IsHole()) {
191 method = JSHandle<Method>(thread, patchVal);
192 } else {
193 method->SetConstantPool(thread, constpool);
194 }
195 JSHandle<JSHClass> hclass = JSHandle<JSHClass>::Cast(env->GetFunctionClassWithProto());
196 JSHandle<JSFunction> mainFunc = factory->NewJSFunctionByHClass(method, hclass);
197 // Main function is created profileTypeInfo by default.
198 if (thread->IsPGOProfilerEnable()) {
199 SlowRuntimeStub::NotifyInlineCache(thread, mainFunc.GetObject<JSFunction>());
200 }
201 program->SetMainFunction(thread, mainFunc.GetTaggedValue());
202 }
203 return program;
204 }
205
ParseConstPool( EcmaVM *vm, const JSPandaFile *jsPandaFile)206 std::pair<JSHandle<ConstantPool>, JSHandle<ConstantPool>> PandaFileTranslator::ParseConstPool(
207 EcmaVM *vm, const JSPandaFile *jsPandaFile)
208 {
209 JSThread *thread = vm->GetJSThread();
210 ObjectFactory *factory = vm->GetFactory();
211 JSHandle<ConstantPool> sconstpool = AllocateSharedConstPool(vm, jsPandaFile);
212 JSHandle<ConstantPool> constpool = AllocateConstPool(vm, jsPandaFile);
213
214 [[maybe_unused]] EcmaHandleScope handleScope(thread);
215 const CUnorderedMap<uint32_t, uint64_t> &constpoolMap = jsPandaFile->GetConstpoolMap();
216 for (const auto &it : constpoolMap) {
217 ConstPoolValue value(it.second);
218 ConstPoolType type = value.GetConstpoolType();
219 if (type == ConstPoolType::STRING) {
220 panda_file::File::EntityId id(it.first);
221 auto foundStr = jsPandaFile->GetStringData(id);
222 auto string = factory->GetRawStringFromStringTable(foundStr, MemSpaceType::SHARED_OLD_SPACE,
223 jsPandaFile->IsFirstMergedAbc(), it.first);
224 constpool->SetObjectToCache(thread, value.GetConstpoolIndex(), JSTaggedValue(string));
225 } else if (type == ConstPoolType::OBJECT_LITERAL) {
226 size_t index = static_cast<size_t>(it.first);
227 JSMutableHandle<TaggedArray> elements(thread, JSTaggedValue::Undefined());
228 JSMutableHandle<TaggedArray> properties(thread, JSTaggedValue::Undefined());
229 LiteralDataExtractor::ExtractObjectDatas(
230 thread, jsPandaFile, index, elements, properties, sconstpool);
231 JSHandle<JSObject> obj = JSObject::CreateObjectFromProperties(thread, properties);
232 JSMutableHandle<JSTaggedValue> key(thread, JSTaggedValue::Undefined());
233 JSMutableHandle<JSTaggedValue> valueHandle(thread, JSTaggedValue::Undefined());
234 size_t elementsLen = elements->GetLength();
235 for (size_t i = 0; i < elementsLen; i += 2) { // 2: Each literal buffer contains a pair of key-value.
236 key.Update(elements->Get(i));
237 if (key->IsHole()) {
238 break;
239 }
240 valueHandle.Update(elements->Get(i + 1));
241 JSObject::DefinePropertyByLiteral(thread, obj, key, valueHandle);
242 }
243 constpool->SetObjectToCache(thread, value.GetConstpoolIndex(), obj.GetTaggedValue());
244 } else if (type == ConstPoolType::ARRAY_LITERAL) {
245 size_t index = static_cast<size_t>(it.first);
246 JSHandle<TaggedArray> literal = LiteralDataExtractor::GetDatasIgnoreType(
247 thread, jsPandaFile, index, sconstpool);
248 uint32_t length = literal->GetLength();
249
250 JSHandle<JSArray> arr(JSArray::ArrayCreate(thread, JSTaggedNumber(length)));
251 arr->SetElements(thread, literal);
252 constpool->SetObjectToCache(thread, value.GetConstpoolIndex(), arr.GetTaggedValue());
253 } else if (type == ConstPoolType::CLASS_LITERAL) {
254 size_t index = static_cast<size_t>(it.first);
255 JSHandle<TaggedArray> literal = LiteralDataExtractor::GetDatasIgnoreTypeForClass(
256 thread, jsPandaFile, index, sconstpool);
257 JSHandle<ClassLiteral> classLiteral = factory->NewClassLiteral();
258 classLiteral->SetArray(thread, literal);
259 constpool->SetObjectToCache(thread, value.GetConstpoolIndex(), classLiteral.GetTaggedValue());
260 } else {
261 ASSERT(type == ConstPoolType::BASE_FUNCTION || type == ConstPoolType::NC_FUNCTION ||
262 type == ConstPoolType::GENERATOR_FUNCTION || type == ConstPoolType::ASYNC_FUNCTION ||
263 type == ConstPoolType::CLASS_FUNCTION || type == ConstPoolType::METHOD ||
264 type == ConstPoolType::ASYNC_GENERATOR_FUNCTION);
265 MethodLiteral *methodLiteral = jsPandaFile->FindMethodLiteral(it.first);
266 CHECK_INPUT_NULLPTR(methodLiteral,
267 "ParseConstPool:methodLiteral is nullptr, offset: " + std::to_string(it.first));
268 methodLiteral->SetFunctionKind(JSPandaFile::GetFunctionKind(type));
269
270 JSHandle<Method> method = factory->NewSMethod(methodLiteral);
271 constpool->SetObjectToCache(thread, value.GetConstpoolIndex(), method.GetTaggedValue());
272 method->SetConstantPool(thread, sconstpool.GetTaggedValue());
273 }
274 }
275 return std::make_pair(sconstpool, constpool);
276 }
277
ParseFuncAndLiteralConstPool(EcmaVM *vm, const JSPandaFile *jsPandaFile, const CString &entryPoint, JSHandle<ConstantPool> sconstpool, JSHandle<ConstantPool> constpool)278 void PandaFileTranslator::ParseFuncAndLiteralConstPool(EcmaVM *vm, const JSPandaFile *jsPandaFile,
279 const CString &entryPoint,
280 JSHandle<ConstantPool> sconstpool,
281 JSHandle<ConstantPool> constpool)
282 {
283 auto &recordInfo = const_cast<JSPandaFile *>(jsPandaFile)->FindRecordInfo(entryPoint);
284 JSThread *thread = vm->GetJSThread();
285 ASSERT(!thread->HasPendingException());
286 if (recordInfo.IsParsedConstpoolOfCurrentVM(vm)) {
287 return;
288 }
289
290 ObjectFactory *factory = vm->GetFactory();
291
292 [[maybe_unused]] EcmaHandleScope handleScope(thread);
293 CUnorderedMap<uint32_t, uint64_t> constpoolMap = *jsPandaFile->GetConstpoolMapByReocrd(entryPoint);
294 for (const auto &it : constpoolMap) {
295 ConstPoolValue value(it.second);
296 ConstPoolType type = value.GetConstpoolType();
297 if (type == ConstPoolType::OBJECT_LITERAL) {
298 size_t index = static_cast<size_t>(it.first);
299 JSMutableHandle<TaggedArray> elements(thread, JSTaggedValue::Undefined());
300 JSMutableHandle<TaggedArray> properties(thread, JSTaggedValue::Undefined());
301 LiteralDataExtractor::ExtractObjectDatas(
302 thread, jsPandaFile, index, elements, properties, sconstpool, entryPoint);
303 JSHandle<JSObject> obj = JSObject::CreateObjectFromProperties(thread, properties);
304 JSMutableHandle<JSTaggedValue> key(thread, JSTaggedValue::Undefined());
305 JSMutableHandle<JSTaggedValue> valueHandle(thread, JSTaggedValue::Undefined());
306 size_t elementsLen = elements->GetLength();
307 for (size_t i = 0; i < elementsLen; i += 2) { // 2: Each literal buffer contains a pair of key-value.
308 key.Update(elements->Get(i));
309 if (key->IsHole()) {
310 break;
311 }
312 valueHandle.Update(elements->Get(i + 1));
313 JSObject::DefinePropertyByLiteral(thread, obj, key, valueHandle);
314 }
315 constpool->SetObjectToCache(thread, value.GetConstpoolIndex(), obj.GetTaggedValue());
316 } else if (type == ConstPoolType::ARRAY_LITERAL) {
317 size_t index = static_cast<size_t>(it.first);
318 JSHandle<TaggedArray> literal = LiteralDataExtractor::GetDatasIgnoreType(
319 thread, jsPandaFile, index, sconstpool, entryPoint);
320 uint32_t length = literal->GetLength();
321 JSHandle<JSArray> arr(JSArray::ArrayCreate(thread, JSTaggedNumber(length)));
322 arr->SetElements(thread, literal);
323 constpool->SetObjectToCache(thread, value.GetConstpoolIndex(), arr.GetTaggedValue());
324 } else if (type == ConstPoolType::CLASS_LITERAL) {
325 size_t index = static_cast<size_t>(it.first);
326 JSHandle<TaggedArray> literal = LiteralDataExtractor::GetDatasIgnoreTypeForClass(
327 thread, jsPandaFile, index, sconstpool, entryPoint);
328 JSHandle<ClassLiteral> classLiteral = factory->NewClassLiteral();
329 classLiteral->SetArray(thread, literal);
330 constpool->SetObjectToCache(thread, value.GetConstpoolIndex(), classLiteral.GetTaggedValue());
331 } else {
332 ASSERT(type == ConstPoolType::BASE_FUNCTION || type == ConstPoolType::NC_FUNCTION ||
333 type == ConstPoolType::GENERATOR_FUNCTION || type == ConstPoolType::ASYNC_FUNCTION ||
334 type == ConstPoolType::CLASS_FUNCTION || type == ConstPoolType::METHOD ||
335 type == ConstPoolType::ASYNC_GENERATOR_FUNCTION);
336 MethodLiteral *methodLiteral = jsPandaFile->FindMethodLiteral(it.first);
337 CHECK_INPUT_NULLPTR(methodLiteral, "ParseFuncAndLiteralConstPool:methodLiteral is nullptr, offset: "
338 + std::to_string(it.first));
339 methodLiteral->SetFunctionKind(JSPandaFile::GetFunctionKind(type));
340
341 JSHandle<Method> method = factory->NewSMethod(methodLiteral);
342 constpool->SetObjectToCache(thread, value.GetConstpoolIndex(), method.GetTaggedValue());
343 method->SetConstantPool(thread, sconstpool.GetTaggedValue());
344 }
345 }
346 recordInfo.SetParsedConstpoolVM(vm);
347 }
348
AllocateSharedConstPool(EcmaVM *vm, const JSPandaFile *jsPandaFile)349 JSHandle<ConstantPool> PandaFileTranslator::AllocateSharedConstPool(EcmaVM *vm, const JSPandaFile *jsPandaFile)
350 {
351 ObjectFactory *factory = vm->GetFactory();
352 uint32_t constpoolIndex = jsPandaFile->GetConstpoolIndex();
353 JSHandle<ConstantPool> sconstpool = factory->NewSConstantPool(constpoolIndex);
354 sconstpool->SetJSPandaFile(jsPandaFile);
355 sconstpool->SetUnsharedConstpoolIndex(JSTaggedValue(0));
356 sconstpool->SetSharedConstpoolId(JSTaggedValue(0)); // 0 :old version has one constpool.
357 return sconstpool;
358 }
359
AllocateConstPool(EcmaVM *vm, const JSPandaFile *jsPandaFile)360 JSHandle<ConstantPool> PandaFileTranslator::AllocateConstPool(EcmaVM *vm, const JSPandaFile *jsPandaFile)
361 {
362 ObjectFactory *factory = vm->GetFactory();
363 uint32_t constpoolIndex = jsPandaFile->GetConstpoolIndex();
364 JSHandle<ConstantPool> constpool = factory->NewConstantPool(constpoolIndex);
365 constpool->SetJSPandaFile(jsPandaFile);
366 constpool->SetUnsharedConstpoolIndex(JSTaggedValue(ConstantPool::CONSTPOOL_TYPE_FLAG));
367 return constpool;
368 }
369
370 #define ADD_NOP_INST(pc, oldLen, newOpcode) \
371 do { \
372 int newLen = static_cast<int>(BytecodeInstruction::Size(newOpcode)); \
373 int paddingSize = static_cast<int>(oldLen) - newLen; \
374 for (int i = 0; i < paddingSize; i++) { \
375 *(pc + newLen + i) = static_cast<uint8_t>(EcmaOpcode::NOP); \
376 } \
377 } while (false)
378
FixOpcode(MethodLiteral *method, const OldBytecodeInst &inst)379 void PandaFileTranslator::FixOpcode(MethodLiteral *method, const OldBytecodeInst &inst)
380 {
381 auto opcode = inst.GetOpcode();
382 EcmaOpcode newOpcode;
383 auto oldLen = OldBytecodeInst::Size(OldBytecodeInst::GetFormat(opcode));
384 auto pc = const_cast<uint8_t *>(inst.GetAddress());
385
386 // First level opcode
387 if (static_cast<uint16_t>(opcode) < 236) { // 236: second level bytecode index
388 switch (opcode) {
389 case OldBytecodeInst::Opcode::MOV_V4_V4: {
390 *pc = static_cast<uint8_t>(EcmaOpcode::MOV_V4_V4);
391 break;
392 }
393 case OldBytecodeInst::Opcode::MOV_DYN_V8_V8: {
394 *pc = static_cast<uint8_t>(EcmaOpcode::MOV_V8_V8);
395 break;
396 }
397 case OldBytecodeInst::Opcode::MOV_DYN_V16_V16: {
398 *pc = static_cast<uint8_t>(EcmaOpcode::MOV_V16_V16);
399 break;
400 }
401 case OldBytecodeInst::Opcode::LDA_STR_ID32: {
402 newOpcode = EcmaOpcode::LDA_STR_ID16;
403 uint32_t id = inst.GetId();
404 LOG_ECMA_IF(id > std::numeric_limits<uint16_t>::max(), FATAL) << "Cannot translate to 16 bits: " << id;
405 *pc = static_cast<uint8_t>(newOpcode);
406 uint16_t newId = static_cast<uint16_t>(id);
407 if (memcpy_s(pc + 1, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) {
408 LOG_FULL(FATAL) << "FixOpcode memcpy_s fail";
409 UNREACHABLE();
410 }
411 ADD_NOP_INST(pc, oldLen, newOpcode);
412 break;
413 }
414 case OldBytecodeInst::Opcode::JMP_IMM8: {
415 *pc = static_cast<uint8_t>(EcmaOpcode::JMP_IMM8);
416 break;
417 }
418 case OldBytecodeInst::Opcode::JMP_IMM16: {
419 *pc = static_cast<uint8_t>(EcmaOpcode::JMP_IMM16);
420 break;
421 }
422 case OldBytecodeInst::Opcode::JMP_IMM32: {
423 *pc = static_cast<uint8_t>(EcmaOpcode::JMP_IMM32);
424 break;
425 }
426 case OldBytecodeInst::Opcode::JEQZ_IMM8: {
427 *pc = static_cast<uint8_t>(EcmaOpcode::JEQZ_IMM8);
428 break;
429 }
430 case OldBytecodeInst::Opcode::JEQZ_IMM16: {
431 *pc = static_cast<uint8_t>(EcmaOpcode::JEQZ_IMM16);
432 break;
433 }
434 case OldBytecodeInst::Opcode::JNEZ_IMM8: {
435 *pc = static_cast<uint8_t>(EcmaOpcode::JNEZ_IMM8);
436 break;
437 }
438 case OldBytecodeInst::Opcode::JNEZ_IMM16: {
439 *pc = static_cast<uint8_t>(EcmaOpcode::JNEZ_IMM16);
440 break;
441 }
442 case OldBytecodeInst::Opcode::LDA_DYN_V8: {
443 *pc = static_cast<uint8_t>(EcmaOpcode::LDA_V8);
444 break;
445 }
446 case OldBytecodeInst::Opcode::STA_DYN_V8: {
447 *pc = static_cast<uint8_t>(EcmaOpcode::STA_V8);
448 break;
449 }
450 case OldBytecodeInst::Opcode::LDAI_DYN_IMM32: {
451 *pc = static_cast<uint8_t>(EcmaOpcode::LDAI_IMM32);
452 break;
453 }
454 case OldBytecodeInst::Opcode::FLDAI_DYN_IMM64: {
455 *pc = static_cast<uint8_t>(EcmaOpcode::FLDAI_IMM64);
456 break;
457 }
458 case OldBytecodeInst::Opcode::RETURN_DYN: {
459 *pc = static_cast<uint8_t>(EcmaOpcode::RETURN);
460 break;
461 }
462 default:
463 LOG_FULL(FATAL) << "FixOpcode fail: " << static_cast<uint32_t>(opcode);
464 UNREACHABLE();
465 }
466 return;
467 }
468
469 // New second level bytecode translate
470 constexpr uint8_t opShifLen = 8;
471 constexpr EcmaOpcode throwPrefOp = EcmaOpcode::THROW_PREF_NONE;
472 constexpr EcmaOpcode widePrefOp = EcmaOpcode::WIDE_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8;
473 constexpr EcmaOpcode deprecatedPrefOp = EcmaOpcode::DEPRECATED_LDLEXENV_PREF_NONE;
474 switch (opcode) {
475 // Translate to throw
476 case OldBytecodeInst::Opcode::ECMA_THROWIFSUPERNOTCORRECTCALL_PREF_IMM16: {
477 newOpcode = EcmaOpcode::THROW_IFSUPERNOTCORRECTCALL_PREF_IMM16;
478 *pc = static_cast<uint8_t>(throwPrefOp);
479 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
480 break;
481 }
482 case OldBytecodeInst::Opcode::ECMA_THROWUNDEFINEDIFHOLE_PREF_V8_V8: {
483 newOpcode = EcmaOpcode::THROW_UNDEFINEDIFHOLE_PREF_V8_V8;
484 *pc = static_cast<uint8_t>(throwPrefOp);
485 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
486 break;
487 }
488 case OldBytecodeInst::Opcode::ECMA_THROWIFNOTOBJECT_PREF_V8: {
489 newOpcode = EcmaOpcode::THROW_IFNOTOBJECT_PREF_V8;
490 *pc = static_cast<uint8_t>(throwPrefOp);
491 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
492 break;
493 }
494 case OldBytecodeInst::Opcode::ECMA_THROWCONSTASSIGNMENT_PREF_V8: {
495 newOpcode = EcmaOpcode::THROW_CONSTASSIGNMENT_PREF_V8;
496 *pc = static_cast<uint8_t>(throwPrefOp);
497 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
498 break;
499 }
500 case OldBytecodeInst::Opcode::ECMA_THROWDELETESUPERPROPERTY_PREF_NONE: {
501 newOpcode = EcmaOpcode::THROW_DELETESUPERPROPERTY_PREF_NONE;
502 *pc = static_cast<uint8_t>(throwPrefOp);
503 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
504 break;
505 }
506 case OldBytecodeInst::Opcode::ECMA_THROWPATTERNNONCOERCIBLE_PREF_NONE: {
507 newOpcode = EcmaOpcode::THROW_PATTERNNONCOERCIBLE_PREF_NONE;
508 *pc = static_cast<uint8_t>(throwPrefOp);
509 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
510 break;
511 }
512 case OldBytecodeInst::Opcode::ECMA_THROWTHROWNOTEXISTS_PREF_NONE: {
513 newOpcode = EcmaOpcode::THROW_NOTEXISTS_PREF_NONE;
514 *pc = static_cast<uint8_t>(throwPrefOp);
515 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
516 break;
517 }
518 case OldBytecodeInst::Opcode::ECMA_THROWDYN_PREF_NONE: {
519 newOpcode = EcmaOpcode::THROW_PREF_NONE;
520 *pc = static_cast<uint8_t>(throwPrefOp);
521 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
522 break;
523 }
524 // Translate to wide
525 case OldBytecodeInst::Opcode::ECMA_LDLEXVARDYN_PREF_IMM16_IMM16: {
526 newOpcode = EcmaOpcode::WIDE_LDLEXVAR_PREF_IMM16_IMM16;
527 *pc = static_cast<uint8_t>(widePrefOp);
528 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
529 break;
530 }
531 case OldBytecodeInst::Opcode::ECMA_COPYRESTARGS_PREF_IMM16: {
532 newOpcode = EcmaOpcode::WIDE_COPYRESTARGS_PREF_IMM16;
533 *pc = static_cast<uint8_t>(widePrefOp);
534 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
535 break;
536 }
537 case OldBytecodeInst::Opcode::ECMA_STOWNBYINDEX_PREF_V8_IMM32: {
538 newOpcode = EcmaOpcode::WIDE_STOWNBYINDEX_PREF_V8_IMM32;
539 *pc = static_cast<uint8_t>(widePrefOp);
540 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
541 break;
542 }
543 case OldBytecodeInst::Opcode::ECMA_STOBJBYINDEX_PREF_V8_IMM32: {
544 newOpcode = EcmaOpcode::WIDE_STOBJBYINDEX_PREF_V8_IMM32;
545 *pc = static_cast<uint8_t>(widePrefOp);
546 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
547 break;
548 }
549 case OldBytecodeInst::Opcode::ECMA_NEWLEXENVWITHNAMEDYN_PREF_IMM16_IMM16: {
550 newOpcode = EcmaOpcode::WIDE_NEWLEXENVWITHNAME_PREF_IMM16_ID16;
551 *pc = static_cast<uint8_t>(widePrefOp);
552 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
553 break;
554 }
555 case OldBytecodeInst::Opcode::ECMA_NEWLEXENVDYN_PREF_IMM16: {
556 newOpcode = EcmaOpcode::WIDE_NEWLEXENV_PREF_IMM16;
557 *pc = static_cast<uint8_t>(widePrefOp);
558 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
559 break;
560 }
561 case OldBytecodeInst::Opcode::ECMA_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8: {
562 newOpcode = EcmaOpcode::WIDE_CREATEOBJECTWITHEXCLUDEDKEYS_PREF_IMM16_V8_V8;
563 *pc = static_cast<uint8_t>(widePrefOp);
564 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
565 break;
566 }
567 case OldBytecodeInst::Opcode::ECMA_SUPERCALL_PREF_IMM16_V8: {
568 newOpcode = EcmaOpcode::WIDE_SUPERCALLARROWRANGE_PREF_IMM16_V8;
569 *pc = static_cast<uint8_t>(widePrefOp);
570 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
571 break;
572 }
573 case OldBytecodeInst::Opcode::ECMA_LDPATCHVAR_PREF_IMM16: {
574 newOpcode = EcmaOpcode::WIDE_LDPATCHVAR_PREF_IMM16;
575 *pc = static_cast<uint8_t>(widePrefOp);
576 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
577 break;
578 }
579 case OldBytecodeInst::Opcode::ECMA_STPATCHVAR_PREF_IMM16: {
580 newOpcode = EcmaOpcode::WIDE_STPATCHVAR_PREF_IMM16;
581 *pc = static_cast<uint8_t>(widePrefOp);
582 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
583 break;
584 }
585 // Translate to deprecated
586 case OldBytecodeInst::Opcode::ECMA_STCLASSTOGLOBALRECORD_PREF_ID32: {
587 newOpcode = EcmaOpcode::DEPRECATED_STCLASSTOGLOBALRECORD_PREF_ID32;
588 *pc = static_cast<uint8_t>(deprecatedPrefOp);
589 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
590 break;
591 }
592 case OldBytecodeInst::Opcode::ECMA_STLETTOGLOBALRECORD_PREF_ID32: {
593 newOpcode = EcmaOpcode::DEPRECATED_STLETTOGLOBALRECORD_PREF_ID32;
594 *pc = static_cast<uint8_t>(deprecatedPrefOp);
595 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
596 break;
597 }
598 case OldBytecodeInst::Opcode::ECMA_STCONSTTOGLOBALRECORD_PREF_ID32: {
599 newOpcode = EcmaOpcode::DEPRECATED_STCONSTTOGLOBALRECORD_PREF_ID32;
600 *pc = static_cast<uint8_t>(deprecatedPrefOp);
601 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
602 break;
603 }
604 case OldBytecodeInst::Opcode::ECMA_LDMODULEVAR_PREF_ID32_IMM8: {
605 newOpcode = EcmaOpcode::DEPRECATED_LDMODULEVAR_PREF_ID32_IMM8;
606 *pc = static_cast<uint8_t>(deprecatedPrefOp);
607 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
608 break;
609 }
610 case OldBytecodeInst::Opcode::ECMA_LDSUPERBYNAME_PREF_ID32_V8: {
611 newOpcode = EcmaOpcode::DEPRECATED_LDSUPERBYNAME_PREF_ID32_V8;
612 *pc = static_cast<uint8_t>(deprecatedPrefOp);
613 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
614 break;
615 }
616 case OldBytecodeInst::Opcode::ECMA_LDOBJBYNAME_PREF_ID32_V8: {
617 newOpcode = EcmaOpcode::DEPRECATED_LDOBJBYNAME_PREF_ID32_V8;
618 *pc = static_cast<uint8_t>(deprecatedPrefOp);
619 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
620 break;
621 }
622 case OldBytecodeInst::Opcode::ECMA_STMODULEVAR_PREF_ID32: {
623 newOpcode = EcmaOpcode::DEPRECATED_STMODULEVAR_PREF_ID32;
624 *pc = static_cast<uint8_t>(deprecatedPrefOp);
625 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
626 break;
627 }
628 case OldBytecodeInst::Opcode::ECMA_GETMODULENAMESPACE_PREF_ID32: {
629 newOpcode = EcmaOpcode::DEPRECATED_GETMODULENAMESPACE_PREF_ID32;
630 *pc = static_cast<uint8_t>(deprecatedPrefOp);
631 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
632 break;
633 }
634 case OldBytecodeInst::Opcode::ECMA_STLEXVARDYN_PREF_IMM16_IMM16_V8: {
635 newOpcode = EcmaOpcode::DEPRECATED_STLEXVAR_PREF_IMM16_IMM16_V8;
636 *pc = static_cast<uint8_t>(deprecatedPrefOp);
637 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
638 break;
639 }
640 case OldBytecodeInst::Opcode::ECMA_STLEXVARDYN_PREF_IMM8_IMM8_V8: {
641 newOpcode = EcmaOpcode::DEPRECATED_STLEXVAR_PREF_IMM8_IMM8_V8;
642 *pc = static_cast<uint8_t>(deprecatedPrefOp);
643 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
644 break;
645 }
646 case OldBytecodeInst::Opcode::ECMA_STLEXVARDYN_PREF_IMM4_IMM4_V8: {
647 newOpcode = EcmaOpcode::DEPRECATED_STLEXVAR_PREF_IMM4_IMM4_V8;
648 *pc = static_cast<uint8_t>(deprecatedPrefOp);
649 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
650 break;
651 }
652 case OldBytecodeInst::Opcode::ECMA_ASYNCFUNCTIONREJECT_PREF_V8_V8_V8: {
653 newOpcode = EcmaOpcode::DEPRECATED_ASYNCFUNCTIONREJECT_PREF_V8_V8_V8;
654 *pc = static_cast<uint8_t>(deprecatedPrefOp);
655 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
656 break;
657 }
658 case OldBytecodeInst::Opcode::ECMA_ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8: {
659 newOpcode = EcmaOpcode::DEPRECATED_ASYNCFUNCTIONRESOLVE_PREF_V8_V8_V8;
660 *pc = static_cast<uint8_t>(deprecatedPrefOp);
661 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
662 break;
663 }
664 case OldBytecodeInst::Opcode::ECMA_LDOBJBYINDEX_PREF_V8_IMM32: {
665 newOpcode = EcmaOpcode::DEPRECATED_LDOBJBYINDEX_PREF_V8_IMM32;
666 *pc = static_cast<uint8_t>(deprecatedPrefOp);
667 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
668 break;
669 }
670 case OldBytecodeInst::Opcode::ECMA_LDSUPERBYVALUE_PREF_V8_V8: {
671 newOpcode = EcmaOpcode::DEPRECATED_LDSUPERBYVALUE_PREF_V8_V8;
672 *pc = static_cast<uint8_t>(deprecatedPrefOp);
673 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
674 break;
675 }
676 case OldBytecodeInst::Opcode::ECMA_LDOBJBYVALUE_PREF_V8_V8: {
677 newOpcode = EcmaOpcode::DEPRECATED_LDOBJBYVALUE_PREF_V8_V8;
678 *pc = static_cast<uint8_t>(deprecatedPrefOp);
679 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
680 break;
681 }
682 case OldBytecodeInst::Opcode::ECMA_SETOBJECTWITHPROTO_PREF_V8_V8: {
683 newOpcode = EcmaOpcode::DEPRECATED_SETOBJECTWITHPROTO_PREF_V8_V8;
684 *pc = static_cast<uint8_t>(deprecatedPrefOp);
685 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
686 break;
687 }
688 case OldBytecodeInst::Opcode::ECMA_COPYDATAPROPERTIES_PREF_V8_V8: {
689 newOpcode = EcmaOpcode::DEPRECATED_COPYDATAPROPERTIES_PREF_V8_V8;
690 *pc = static_cast<uint8_t>(deprecatedPrefOp);
691 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
692 break;
693 }
694 case OldBytecodeInst::Opcode::ECMA_ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8: {
695 newOpcode = EcmaOpcode::DEPRECATED_ASYNCFUNCTIONAWAITUNCAUGHT_PREF_V8_V8;
696 *pc = static_cast<uint8_t>(deprecatedPrefOp);
697 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
698 break;
699 }
700 case OldBytecodeInst::Opcode::ECMA_SUSPENDGENERATOR_PREF_V8_V8: {
701 newOpcode = EcmaOpcode::DEPRECATED_SUSPENDGENERATOR_PREF_V8_V8;
702 *pc = static_cast<uint8_t>(deprecatedPrefOp);
703 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
704 break;
705 }
706 case OldBytecodeInst::Opcode::ECMA_DELOBJPROP_PREF_V8_V8: {
707 newOpcode = EcmaOpcode::DEPRECATED_DELOBJPROP_PREF_V8_V8;
708 *pc = static_cast<uint8_t>(deprecatedPrefOp);
709 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
710 break;
711 }
712 case OldBytecodeInst::Opcode::ECMA_GETTEMPLATEOBJECT_PREF_V8: {
713 newOpcode = EcmaOpcode::DEPRECATED_GETTEMPLATEOBJECT_PREF_V8;
714 *pc = static_cast<uint8_t>(deprecatedPrefOp);
715 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
716 break;
717 }
718 case OldBytecodeInst::Opcode::ECMA_GETRESUMEMODE_PREF_V8: {
719 newOpcode = EcmaOpcode::DEPRECATED_GETRESUMEMODE_PREF_V8;
720 *pc = static_cast<uint8_t>(deprecatedPrefOp);
721 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
722 break;
723 }
724 case OldBytecodeInst::Opcode::ECMA_RESUMEGENERATOR_PREF_V8: {
725 newOpcode = EcmaOpcode::DEPRECATED_RESUMEGENERATOR_PREF_V8;
726 *pc = static_cast<uint8_t>(deprecatedPrefOp);
727 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
728 break;
729 }
730 case OldBytecodeInst::Opcode::ECMA_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8: {
731 newOpcode = EcmaOpcode::DEPRECATED_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8;
732 *pc = static_cast<uint8_t>(deprecatedPrefOp);
733 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
734 break;
735 }
736 case OldBytecodeInst::Opcode::ECMA_CALLTHISRANGEDYN_PREF_IMM16_V8: {
737 newOpcode = EcmaOpcode::DEPRECATED_CALLTHISRANGE_PREF_IMM16_V8;
738 *pc = static_cast<uint8_t>(deprecatedPrefOp);
739 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
740 break;
741 }
742 case OldBytecodeInst::Opcode::ECMA_CALLSPREADDYN_PREF_V8_V8_V8: {
743 newOpcode = EcmaOpcode::DEPRECATED_CALLSPREAD_PREF_V8_V8_V8;
744 *pc = static_cast<uint8_t>(deprecatedPrefOp);
745 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
746 break;
747 }
748 case OldBytecodeInst::Opcode::ECMA_CALLRANGEDYN_PREF_IMM16_V8: {
749 newOpcode = EcmaOpcode::DEPRECATED_CALLRANGE_PREF_IMM16_V8;
750 *pc = static_cast<uint8_t>(deprecatedPrefOp);
751 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
752 break;
753 }
754 case OldBytecodeInst::Opcode::ECMA_CALLARGS3DYN_PREF_V8_V8_V8_V8: {
755 newOpcode = EcmaOpcode::DEPRECATED_CALLARGS3_PREF_V8_V8_V8_V8;
756 *pc = static_cast<uint8_t>(deprecatedPrefOp);
757 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
758 break;
759 }
760 case OldBytecodeInst::Opcode::ECMA_CALLARGS2DYN_PREF_V8_V8_V8: {
761 newOpcode = EcmaOpcode::DEPRECATED_CALLARGS2_PREF_V8_V8_V8;
762 *pc = static_cast<uint8_t>(deprecatedPrefOp);
763 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
764 break;
765 }
766 case OldBytecodeInst::Opcode::ECMA_CALLARG1DYN_PREF_V8_V8: {
767 newOpcode = EcmaOpcode::DEPRECATED_CALLARG1_PREF_V8_V8;
768 *pc = static_cast<uint8_t>(deprecatedPrefOp);
769 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
770 break;
771 }
772 case OldBytecodeInst::Opcode::ECMA_CALLARG0DYN_PREF_V8: {
773 newOpcode = EcmaOpcode::DEPRECATED_CALLARG0_PREF_V8;
774 *pc = static_cast<uint8_t>(deprecatedPrefOp);
775 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
776 break;
777 }
778 case OldBytecodeInst::Opcode::ECMA_DECDYN_PREF_V8: {
779 newOpcode = EcmaOpcode::DEPRECATED_DEC_PREF_V8;
780 *pc = static_cast<uint8_t>(deprecatedPrefOp);
781 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
782 break;
783 }
784 case OldBytecodeInst::Opcode::ECMA_INCDYN_PREF_V8: {
785 newOpcode = EcmaOpcode::DEPRECATED_INC_PREF_V8;
786 *pc = static_cast<uint8_t>(deprecatedPrefOp);
787 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
788 break;
789 }
790 case OldBytecodeInst::Opcode::ECMA_NOTDYN_PREF_V8: {
791 newOpcode = EcmaOpcode::DEPRECATED_NOT_PREF_V8;
792 *pc = static_cast<uint8_t>(deprecatedPrefOp);
793 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
794 break;
795 }
796 case OldBytecodeInst::Opcode::ECMA_NEGDYN_PREF_V8: {
797 newOpcode = EcmaOpcode::DEPRECATED_NEG_PREF_V8;
798 *pc = static_cast<uint8_t>(deprecatedPrefOp);
799 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
800 break;
801 }
802 case OldBytecodeInst::Opcode::ECMA_TONUMERIC_PREF_V8: {
803 newOpcode = EcmaOpcode::DEPRECATED_TONUMERIC_PREF_V8;
804 *pc = static_cast<uint8_t>(deprecatedPrefOp);
805 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
806 break;
807 }
808 case OldBytecodeInst::Opcode::ECMA_TONUMBER_PREF_V8: {
809 newOpcode = EcmaOpcode::DEPRECATED_TONUMBER_PREF_V8;
810 *pc = static_cast<uint8_t>(deprecatedPrefOp);
811 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
812 break;
813 }
814 case OldBytecodeInst::Opcode::ECMA_CREATEOBJECTWITHBUFFER_PREF_IMM16: {
815 newOpcode = EcmaOpcode::DEPRECATED_CREATEOBJECTWITHBUFFER_PREF_IMM16;
816 *pc = static_cast<uint8_t>(deprecatedPrefOp);
817 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
818 break;
819 }
820 case OldBytecodeInst::Opcode::ECMA_CREATEARRAYWITHBUFFER_PREF_IMM16: {
821 newOpcode = EcmaOpcode::DEPRECATED_CREATEARRAYWITHBUFFER_PREF_IMM16;
822 *pc = static_cast<uint8_t>(deprecatedPrefOp);
823 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
824 break;
825 }
826 case OldBytecodeInst::Opcode::ECMA_GETITERATORNEXT_PREF_V8_V8: {
827 newOpcode = EcmaOpcode::DEPRECATED_GETITERATORNEXT_PREF_V8_V8;
828 *pc = static_cast<uint8_t>(deprecatedPrefOp);
829 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
830 break;
831 }
832 case OldBytecodeInst::Opcode::ECMA_POPLEXENVDYN_PREF_NONE: {
833 newOpcode = EcmaOpcode::DEPRECATED_POPLEXENV_PREF_NONE;
834 *pc = static_cast<uint8_t>(deprecatedPrefOp);
835 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
836 break;
837 }
838 case OldBytecodeInst::Opcode::ECMA_LDLEXENVDYN_PREF_NONE: {
839 newOpcode = EcmaOpcode::DEPRECATED_LDLEXENV_PREF_NONE;
840 *pc = static_cast<uint8_t>(deprecatedPrefOp);
841 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
842 break;
843 }
844 case OldBytecodeInst::Opcode::ECMA_LDHOMEOBJECT_PREF_NONE: {
845 newOpcode = EcmaOpcode::DEPRECATED_LDHOMEOBJECT_PREF_NONE;
846 *pc = static_cast<uint8_t>(deprecatedPrefOp);
847 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
848 break;
849 }
850 case OldBytecodeInst::Opcode::ECMA_CREATEOBJECTHAVINGMETHOD_PREF_IMM16: {
851 newOpcode = EcmaOpcode::DEPRECATED_CREATEOBJECTHAVINGMETHOD_PREF_IMM16;
852 *pc = static_cast<uint8_t>(deprecatedPrefOp);
853 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
854 break;
855 }
856 case OldBytecodeInst::Opcode::ECMA_DYNAMICIMPORT_PREF_V8: {
857 newOpcode = EcmaOpcode::DEPRECATED_DYNAMICIMPORT_PREF_V8;
858 *pc = static_cast<uint8_t>(deprecatedPrefOp);
859 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
860 break;
861 }
862 case OldBytecodeInst::Opcode::ECMA_ASYNCGENERATORREJECT_PREF_V8_V8: {
863 newOpcode = EcmaOpcode::DEPRECATED_ASYNCGENERATORREJECT_PREF_V8_V8;
864 *pc = static_cast<uint8_t>(deprecatedPrefOp);
865 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
866 break;
867 }
868 // The same format has IC
869 case OldBytecodeInst::Opcode::ECMA_TYPEOFDYN_PREF_NONE: {
870 newOpcode = EcmaOpcode::TYPEOF_IMM8;
871 *pc = static_cast<uint8_t>(newOpcode);
872 *(pc + 1) = 0x00;
873 break;
874 }
875 case OldBytecodeInst::Opcode::ECMA_INSTANCEOFDYN_PREF_V8: {
876 newOpcode = EcmaOpcode::INSTANCEOF_IMM8_V8;
877 *pc = static_cast<uint8_t>(newOpcode);
878 *(pc + 1) = 0x00;
879 break;
880 }
881 case OldBytecodeInst::Opcode::ECMA_CREATEEMPTYARRAY_PREF_NONE: {
882 newOpcode = EcmaOpcode::CREATEEMPTYARRAY_IMM8;
883 *pc = static_cast<uint8_t>(newOpcode);
884 *(pc + 1) = 0x00;
885 break;
886 }
887 case OldBytecodeInst::Opcode::ECMA_GETITERATOR_PREF_NONE: {
888 newOpcode = EcmaOpcode::GETITERATOR_IMM8;
889 *pc = static_cast<uint8_t>(newOpcode);
890 *(pc + 1) = 0x00;
891 break;
892 }
893 case OldBytecodeInst::Opcode::ECMA_ADD2DYN_PREF_V8: {
894 newOpcode = EcmaOpcode::ADD2_IMM8_V8;
895 *pc = static_cast<uint8_t>(newOpcode);
896 *(pc + 1) = 0x00;
897 break;
898 }
899 case OldBytecodeInst::Opcode::ECMA_SUB2DYN_PREF_V8: {
900 newOpcode = EcmaOpcode::SUB2_IMM8_V8;
901 *pc = static_cast<uint8_t>(newOpcode);
902 *(pc + 1) = 0x00;
903 break;
904 }
905 case OldBytecodeInst::Opcode::ECMA_MUL2DYN_PREF_V8: {
906 newOpcode = EcmaOpcode::MUL2_IMM8_V8;
907 *pc = static_cast<uint8_t>(newOpcode);
908 *(pc + 1) = 0x00;
909 break;
910 }
911 case OldBytecodeInst::Opcode::ECMA_DIV2DYN_PREF_V8: {
912 newOpcode = EcmaOpcode::DIV2_IMM8_V8;
913 *pc = static_cast<uint8_t>(newOpcode);
914 *(pc + 1) = 0x00;
915 break;
916 }
917 case OldBytecodeInst::Opcode::ECMA_MOD2DYN_PREF_V8: {
918 newOpcode = EcmaOpcode::MOD2_IMM8_V8;
919 *pc = static_cast<uint8_t>(newOpcode);
920 *(pc + 1) = 0x00;
921 break;
922 }
923 case OldBytecodeInst::Opcode::ECMA_EQDYN_PREF_V8: {
924 newOpcode = EcmaOpcode::EQ_IMM8_V8;
925 *pc = static_cast<uint8_t>(newOpcode);
926 *(pc + 1) = 0x00;
927 break;
928 }
929 case OldBytecodeInst::Opcode::ECMA_NOTEQDYN_PREF_V8: {
930 newOpcode = EcmaOpcode::NOTEQ_IMM8_V8;
931 *pc = static_cast<uint8_t>(newOpcode);
932 *(pc + 1) = 0x00;
933 break;
934 }
935 case OldBytecodeInst::Opcode::ECMA_LESSDYN_PREF_V8: {
936 newOpcode = EcmaOpcode::LESS_IMM8_V8;
937 *pc = static_cast<uint8_t>(newOpcode);
938 *(pc + 1) = 0x00;
939 break;
940 }
941 case OldBytecodeInst::Opcode::ECMA_LESSEQDYN_PREF_V8: {
942 newOpcode = EcmaOpcode::LESSEQ_IMM8_V8;
943 *pc = static_cast<uint8_t>(newOpcode);
944 *(pc + 1) = 0x00;
945 break;
946 }
947 case OldBytecodeInst::Opcode::ECMA_GREATERDYN_PREF_V8: {
948 newOpcode = EcmaOpcode::GREATER_IMM8_V8;
949 *pc = static_cast<uint8_t>(newOpcode);
950 *(pc + 1) = 0x00;
951 break;
952 }
953 case OldBytecodeInst::Opcode::ECMA_GREATEREQDYN_PREF_V8: {
954 newOpcode = EcmaOpcode::GREATEREQ_IMM8_V8;
955 *pc = static_cast<uint8_t>(newOpcode);
956 *(pc + 1) = 0x00;
957 break;
958 }
959 case OldBytecodeInst::Opcode::ECMA_SHL2DYN_PREF_V8: {
960 newOpcode = EcmaOpcode::SHL2_IMM8_V8;
961 *pc = static_cast<uint8_t>(newOpcode);
962 *(pc + 1) = 0x00;
963 break;
964 }
965 case OldBytecodeInst::Opcode::ECMA_ASHR2DYN_PREF_V8: {
966 newOpcode = EcmaOpcode::SHR2_IMM8_V8; // old instruction was wrong
967 *pc = static_cast<uint8_t>(newOpcode);
968 *(pc + 1) = 0x00;
969 break;
970 }
971 case OldBytecodeInst::Opcode::ECMA_SHR2DYN_PREF_V8: {
972 newOpcode = EcmaOpcode::ASHR2_IMM8_V8; // old instruction was wrong
973 *pc = static_cast<uint8_t>(newOpcode);
974 *(pc + 1) = 0x00;
975 break;
976 }
977 case OldBytecodeInst::Opcode::ECMA_AND2DYN_PREF_V8: {
978 newOpcode = EcmaOpcode::AND2_IMM8_V8;
979 *pc = static_cast<uint8_t>(newOpcode);
980 *(pc + 1) = 0x00;
981 break;
982 }
983 case OldBytecodeInst::Opcode::ECMA_OR2DYN_PREF_V8: {
984 newOpcode = EcmaOpcode::OR2_IMM8_V8;
985 *pc = static_cast<uint8_t>(newOpcode);
986 *(pc + 1) = 0x00;
987 break;
988 }
989 case OldBytecodeInst::Opcode::ECMA_XOR2DYN_PREF_V8: {
990 newOpcode = EcmaOpcode::XOR2_IMM8_V8;
991 *pc = static_cast<uint8_t>(newOpcode);
992 *(pc + 1) = 0x00;
993 break;
994 }
995 case OldBytecodeInst::Opcode::ECMA_EXPDYN_PREF_V8: {
996 newOpcode = EcmaOpcode::EXP_IMM8_V8;
997 *pc = static_cast<uint8_t>(newOpcode);
998 *(pc + 1) = 0x00;
999 break;
1000 }
1001 case OldBytecodeInst::Opcode::ECMA_ISINDYN_PREF_V8: {
1002 newOpcode = EcmaOpcode::ISIN_IMM8_V8;
1003 *pc = static_cast<uint8_t>(newOpcode);
1004 *(pc + 1) = 0x00;
1005 break;
1006 }
1007 case OldBytecodeInst::Opcode::ECMA_STRICTNOTEQDYN_PREF_V8: {
1008 newOpcode = EcmaOpcode::STRICTNOTEQ_IMM8_V8;
1009 *pc = static_cast<uint8_t>(newOpcode);
1010 *(pc + 1) = 0x00;
1011 break;
1012 }
1013 case OldBytecodeInst::Opcode::ECMA_STRICTEQDYN_PREF_V8: {
1014 newOpcode = EcmaOpcode::STRICTEQ_IMM8_V8;
1015 *pc = static_cast<uint8_t>(newOpcode);
1016 *(pc + 1) = 0x00;
1017 break;
1018 }
1019 case OldBytecodeInst::Opcode::ECMA_ITERNEXT_PREF_V8: {
1020 // *pc = static_cast<uint8_t>(EcmaOpcode::new_op_xxxxxxxx);
1021 // *(pc + 1) = 0x00;
1022 LOG_FULL(FATAL) << "Need Add ITERNEXT Deprecated";
1023 return;
1024 }
1025 case OldBytecodeInst::Opcode::ECMA_CLOSEITERATOR_PREF_V8: {
1026 newOpcode = EcmaOpcode::CLOSEITERATOR_IMM8_V8;
1027 *pc = static_cast<uint8_t>(newOpcode);
1028 *(pc + 1) = 0x00;
1029 break;
1030 }
1031 case OldBytecodeInst::Opcode::ECMA_SUPERCALLSPREAD_PREF_V8: {
1032 newOpcode = EcmaOpcode::SUPERCALLSPREAD_IMM8_V8;
1033 *pc = static_cast<uint8_t>(newOpcode);
1034 *(pc + 1) = 0x00;
1035 break;
1036 }
1037 case OldBytecodeInst::Opcode::ECMA_STOBJBYVALUE_PREF_V8_V8: {
1038 newOpcode = EcmaOpcode::STOBJBYVALUE_IMM8_V8_V8;
1039 *pc = static_cast<uint8_t>(newOpcode);
1040 *(pc + 1) = 0x00;
1041 break;
1042 }
1043 case OldBytecodeInst::Opcode::ECMA_STOWNBYVALUE_PREF_V8_V8: {
1044 newOpcode = EcmaOpcode::STOWNBYVALUE_IMM8_V8_V8;
1045 *pc = static_cast<uint8_t>(newOpcode);
1046 *(pc + 1) = 0x00;
1047 break;
1048 }
1049 case OldBytecodeInst::Opcode::ECMA_STSUPERBYVALUE_PREF_V8_V8: {
1050 newOpcode = EcmaOpcode::STSUPERBYVALUE_IMM8_V8_V8;
1051 *pc = static_cast<uint8_t>(newOpcode);
1052 *(pc + 1) = 0x00;
1053 break;
1054 }
1055 case OldBytecodeInst::Opcode::ECMA_STOWNBYVALUEWITHNAMESET_PREF_V8_V8: {
1056 newOpcode = EcmaOpcode::STOWNBYVALUEWITHNAMESET_IMM8_V8_V8;
1057 *pc = static_cast<uint8_t>(newOpcode);
1058 *(pc + 1) = 0x00;
1059 break;
1060 }
1061 // The same format no IC
1062 case OldBytecodeInst::Opcode::ECMA_ASYNCFUNCTIONENTER_PREF_NONE: {
1063 newOpcode = EcmaOpcode::ASYNCFUNCTIONENTER;
1064 *pc = static_cast<uint8_t>(newOpcode);
1065 break;
1066 }
1067 case OldBytecodeInst::Opcode::ECMA_ASYNCGENERATORRESOLVE_PREF_V8_V8_V8: {
1068 newOpcode = EcmaOpcode::ASYNCGENERATORRESOLVE_V8_V8_V8;
1069 *pc = static_cast<uint8_t>(newOpcode);
1070 auto newLen = BytecodeInstruction::Size(newOpcode);
1071 if (memmove_s(pc + 1, newLen - 1, pc + 2, oldLen - 2) != EOK) { // 2: skip second level inst and pref
1072 LOG_FULL(FATAL) << "FixOpcode memmove_s fail";
1073 UNREACHABLE();
1074 }
1075 break;
1076 }
1077 case OldBytecodeInst::Opcode::ECMA_CREATEASYNCGENERATOROBJ_PREF_V8: {
1078 newOpcode = EcmaOpcode::CREATEASYNCGENERATOROBJ_V8;
1079 *pc = static_cast<uint8_t>(newOpcode);
1080 auto newLen = BytecodeInstruction::Size(newOpcode);
1081 if (memmove_s(pc + 1, newLen - 1, pc + 2, oldLen - 2) != EOK) { // 2: skip second level inst and pref
1082 LOG_FULL(FATAL) << "FixOpcode memmove_s fail";
1083 UNREACHABLE();
1084 }
1085 break;
1086 }
1087 case OldBytecodeInst::Opcode::ECMA_CREATEEMPTYOBJECT_PREF_NONE: {
1088 newOpcode = EcmaOpcode::CREATEEMPTYOBJECT;
1089 *pc = static_cast<uint8_t>(newOpcode);
1090 break;
1091 }
1092 case OldBytecodeInst::Opcode::ECMA_CREATEGENERATOROBJ_PREF_V8: {
1093 newOpcode = EcmaOpcode::CREATEGENERATOROBJ_V8;
1094 *pc = static_cast<uint8_t>(newOpcode);
1095 auto newLen = BytecodeInstruction::Size(newOpcode);
1096 if (memmove_s(pc + 1, newLen - 1, pc + 2, oldLen - 2) != EOK) { // 2: skip second level inst and pref
1097 LOG_FULL(FATAL) << "FixOpcode memmove_s fail";
1098 UNREACHABLE();
1099 }
1100 break;
1101 }
1102 case OldBytecodeInst::Opcode::ECMA_CREATEITERRESULTOBJ_PREF_V8_V8: {
1103 newOpcode = EcmaOpcode::CREATEITERRESULTOBJ_V8_V8;
1104 *pc = static_cast<uint8_t>(newOpcode);
1105 auto newLen = BytecodeInstruction::Size(newOpcode);
1106 if (memmove_s(pc + 1, newLen - 1, pc + 2, oldLen - 2) != EOK) { // 2: skip second level inst and pref
1107 LOG_FULL(FATAL) << "FixOpcode memmove_s fail";
1108 UNREACHABLE();
1109 }
1110 break;
1111 }
1112 case OldBytecodeInst::Opcode::ECMA_DEBUGGER_PREF_NONE: {
1113 newOpcode = EcmaOpcode::DEBUGGER;
1114 *pc = static_cast<uint8_t>(newOpcode);
1115 break;
1116 }
1117 case OldBytecodeInst::Opcode::ECMA_DEFINEGETTERSETTERBYVALUE_PREF_V8_V8_V8_V8: {
1118 newOpcode = EcmaOpcode::DEFINEGETTERSETTERBYVALUE_V8_V8_V8_V8;
1119 *pc = static_cast<uint8_t>(newOpcode);
1120 auto newLen = BytecodeInstruction::Size(newOpcode);
1121 if (memmove_s(pc + 1, newLen - 1, pc + 2, oldLen - 2) != EOK) { // 2: skip second level inst and pref
1122 LOG_FULL(FATAL) << "FixOpcode memmove_s fail";
1123 UNREACHABLE();
1124 }
1125 break;
1126 }
1127 case OldBytecodeInst::Opcode::ECMA_GETNEXTPROPNAME_PREF_V8: {
1128 newOpcode = EcmaOpcode::GETNEXTPROPNAME_V8;
1129 *pc = static_cast<uint8_t>(newOpcode);
1130 auto newLen = BytecodeInstruction::Size(newOpcode);
1131 if (memmove_s(pc + 1, newLen - 1, pc + 2, oldLen - 2) != EOK) { // 2: skip second level inst and pref
1132 LOG_FULL(FATAL) << "FixOpcode memmove_s fail";
1133 UNREACHABLE();
1134 }
1135 break;
1136 }
1137 case OldBytecodeInst::Opcode::ECMA_GETPROPITERATOR_PREF_NONE: {
1138 newOpcode = EcmaOpcode::GETPROPITERATOR;
1139 *pc = static_cast<uint8_t>(newOpcode);
1140 break;
1141 }
1142 case OldBytecodeInst::Opcode::ECMA_GETUNMAPPEDARGS_PREF_NONE: {
1143 newOpcode = EcmaOpcode::GETUNMAPPEDARGS;
1144 *pc = static_cast<uint8_t>(newOpcode);
1145 break;
1146 }
1147 case OldBytecodeInst::Opcode::ECMA_ISFALSE_PREF_NONE: {
1148 newOpcode = EcmaOpcode::ISFALSE;
1149 *pc = static_cast<uint8_t>(newOpcode);
1150 break;
1151 }
1152 case OldBytecodeInst::Opcode::ECMA_ISTRUE_PREF_NONE: {
1153 newOpcode = EcmaOpcode::ISTRUE;
1154 *pc = static_cast<uint8_t>(newOpcode);
1155 break;
1156 }
1157 case OldBytecodeInst::Opcode::ECMA_LDFALSE_PREF_NONE: {
1158 newOpcode = EcmaOpcode::LDFALSE;
1159 *pc = static_cast<uint8_t>(newOpcode);
1160 break;
1161 }
1162 case OldBytecodeInst::Opcode::ECMA_LDTRUE_PREF_NONE: {
1163 newOpcode = EcmaOpcode::LDTRUE;
1164 *pc = static_cast<uint8_t>(newOpcode);
1165 break;
1166 }
1167 case OldBytecodeInst::Opcode::ECMA_LDFUNCTION_PREF_NONE: {
1168 newOpcode = EcmaOpcode::LDFUNCTION;
1169 *pc = static_cast<uint8_t>(newOpcode);
1170 break;
1171 }
1172 case OldBytecodeInst::Opcode::ECMA_LDGLOBALTHIS_PREF_NONE: {
1173 newOpcode = EcmaOpcode::LDGLOBAL;
1174 *pc = static_cast<uint8_t>(newOpcode);
1175 break;
1176 }
1177 case OldBytecodeInst::Opcode::ECMA_LDGLOBAL_PREF_NONE: {
1178 newOpcode = EcmaOpcode::LDGLOBAL;
1179 *pc = static_cast<uint8_t>(newOpcode);
1180 break;
1181 }
1182 case OldBytecodeInst::Opcode::ECMA_LDHOLE_PREF_NONE: {
1183 newOpcode = EcmaOpcode::LDHOLE;
1184 *pc = static_cast<uint8_t>(newOpcode);
1185 break;
1186 }
1187 case OldBytecodeInst::Opcode::ECMA_LDNULL_PREF_NONE: {
1188 newOpcode = EcmaOpcode::LDNULL;
1189 *pc = static_cast<uint8_t>(newOpcode);
1190 break;
1191 }
1192 case OldBytecodeInst::Opcode::ECMA_LDSYMBOL_PREF_NONE: {
1193 newOpcode = EcmaOpcode::LDSYMBOL;
1194 *pc = static_cast<uint8_t>(newOpcode);
1195 break;
1196 }
1197 case OldBytecodeInst::Opcode::ECMA_LDUNDEFINED_PREF_NONE: {
1198 newOpcode = EcmaOpcode::LDUNDEFINED;
1199 *pc = static_cast<uint8_t>(newOpcode);
1200 break;
1201 }
1202 case OldBytecodeInst::Opcode::ECMA_LDNAN_PREF_NONE: {
1203 newOpcode = EcmaOpcode::LDNAN;
1204 *pc = static_cast<uint8_t>(newOpcode);
1205 break;
1206 }
1207 case OldBytecodeInst::Opcode::ECMA_LDINFINITY_PREF_NONE: {
1208 newOpcode = EcmaOpcode::LDINFINITY;
1209 *pc = static_cast<uint8_t>(newOpcode);
1210 break;
1211 }
1212 case OldBytecodeInst::Opcode::ECMA_RETURNUNDEFINED_PREF_NONE: {
1213 newOpcode = EcmaOpcode::RETURNUNDEFINED;
1214 *pc = static_cast<uint8_t>(newOpcode);
1215 break;
1216 }
1217 case OldBytecodeInst::Opcode::ECMA_NEWOBJDYNRANGE_PREF_IMM16_V8: {
1218 newOpcode = EcmaOpcode::WIDE_NEWOBJRANGE_PREF_IMM16_V8;
1219 *pc = static_cast<uint8_t>(widePrefOp);
1220 *(pc + 1) = static_cast<uint16_t>(newOpcode) >> opShifLen;
1221
1222 uint16_t imm = static_cast<uint16_t>(inst.GetImm<OldBytecodeInst::Format::PREF_IMM16_V8>() - 1);
1223 if (memcpy_s(pc + 2, sizeof(uint16_t), &imm, sizeof(uint16_t)) != EOK) { // 2: skip opcode and ic slot
1224 LOG_FULL(FATAL) << "FixOpcode memcpy_s fail";
1225 UNREACHABLE();
1226 }
1227 *(pc + 4) = *(pc + 4) + 1; // 4: index of new opcode; 4: index of old opcode
1228 break;
1229 }
1230 case OldBytecodeInst::Opcode::ECMA_LDLEXVARDYN_PREF_IMM4_IMM4: {
1231 newOpcode = EcmaOpcode::LDLEXVAR_IMM4_IMM4;
1232 *pc = static_cast<uint8_t>(newOpcode);
1233 auto newLen = BytecodeInstruction::Size(newOpcode);
1234 if (memmove_s(pc + 1, newLen - 1, pc + 2, oldLen - 2) != EOK) { // 2: skip second level inst and pref
1235 LOG_FULL(FATAL) << "FixOpcode memmove_s fail";
1236 UNREACHABLE();
1237 }
1238 break;
1239 }
1240 case OldBytecodeInst::Opcode::ECMA_LDLEXVARDYN_PREF_IMM8_IMM8: {
1241 newOpcode = EcmaOpcode::LDLEXVAR_IMM8_IMM8;
1242 *pc = static_cast<uint8_t>(newOpcode);
1243 auto newLen = BytecodeInstruction::Size(newOpcode);
1244 if (memmove_s(pc + 1, newLen - 1, pc + 2, oldLen - 2) != EOK) { // 2: skip second level inst and pref
1245 LOG_FULL(FATAL) << "FixOpcode memmove_s fail";
1246 UNREACHABLE();
1247 }
1248 break;
1249 }
1250 case OldBytecodeInst::Opcode::ECMA_STARRAYSPREAD_PREF_V8_V8: {
1251 newOpcode = EcmaOpcode::STARRAYSPREAD_V8_V8;
1252 *pc = static_cast<uint8_t>(newOpcode);
1253 auto newLen = BytecodeInstruction::Size(newOpcode);
1254 // 2: skip opcode and second level pref
1255 if (memmove_s(pc + 1, newLen - 1, pc + 2, oldLen - 2) != EOK) {
1256 LOG_FULL(FATAL) << "FixOpcode memmove_s fail";
1257 UNREACHABLE();
1258 }
1259 break;
1260 }
1261 // ID32 to ID16 has IC (PREF_ID32)
1262 case OldBytecodeInst::Opcode::ECMA_TRYLDGLOBALBYNAME_PREF_ID32: {
1263 newOpcode = EcmaOpcode::TRYLDGLOBALBYNAME_IMM8_ID16;
1264 uint32_t id = inst.GetId();
1265 LOG_ECMA_IF(id > std::numeric_limits<uint16_t>::max(), FATAL) << "Cannot translate to 16 bits: " << id;
1266 *pc = static_cast<uint8_t>(newOpcode);
1267 *(pc + 1) = 0x00;
1268 uint16_t newId = static_cast<uint16_t>(id);
1269 if (memcpy_s(pc + 2, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { // 2: skip opcode and ic slot
1270 LOG_FULL(FATAL) << "FixOpcode memcpy_s fail";
1271 UNREACHABLE();
1272 }
1273 break;
1274 }
1275 case OldBytecodeInst::Opcode::ECMA_TRYSTGLOBALBYNAME_PREF_ID32: {
1276 newOpcode = EcmaOpcode::TRYSTGLOBALBYNAME_IMM8_ID16;
1277 uint32_t id = inst.GetId();
1278 LOG_ECMA_IF(id > std::numeric_limits<uint16_t>::max(), FATAL) << "Cannot translate to 16 bits: " << id;
1279 *pc = static_cast<uint8_t>(newOpcode);
1280 *(pc + 1) = 0x00;
1281 uint16_t newId = static_cast<uint16_t>(id);
1282 if (memcpy_s(pc + 2, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { // 2: skip opcode and ic slot
1283 LOG_FULL(FATAL) << "FixOpcode memcpy_s fail";
1284 UNREACHABLE();
1285 }
1286 break;
1287 }
1288 // ID32 to ID16 has IC (ID32_V8 & ID32_IMM8)
1289 case OldBytecodeInst::Opcode::ECMA_STOBJBYNAME_PREF_ID32_V8: {
1290 newOpcode = EcmaOpcode::STOBJBYNAME_IMM8_ID16_V8;
1291 uint32_t id = inst.GetId();
1292 LOG_ECMA_IF(id > std::numeric_limits<uint16_t>::max(), FATAL) << "Cannot translate to 16 bits: " << id;
1293 *pc = static_cast<uint8_t>(newOpcode);
1294 *(pc + 1) = 0x00;
1295 uint16_t newId = static_cast<uint16_t>(id);
1296 if (memcpy_s(pc + 2, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { // 2: skip opcode and ic slot
1297 LOG_FULL(FATAL) << "FixOpcode memcpy_s fail";
1298 UNREACHABLE();
1299 }
1300 *(pc + 4) = *(pc + 6); // 4: index of new opcode; 6: index of old opcode
1301 break;
1302 }
1303 case OldBytecodeInst::Opcode::ECMA_STOWNBYNAME_PREF_ID32_V8: {
1304 newOpcode = EcmaOpcode::STOWNBYNAME_IMM8_ID16_V8;
1305 uint32_t id = inst.GetId();
1306 LOG_ECMA_IF(id > std::numeric_limits<uint16_t>::max(), FATAL) << "Cannot translate to 16 bits: " << id;
1307 *pc = static_cast<uint8_t>(newOpcode);
1308 *(pc + 1) = 0x00;
1309 uint16_t newId = static_cast<uint16_t>(id);
1310 if (memcpy_s(pc + 2, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { // 2: skip opcode and ic slot
1311 LOG_FULL(FATAL) << "FixOpcode memcpy_s fail";
1312 UNREACHABLE();
1313 }
1314 *(pc + 4) = *(pc + 6); // 4: index of new opcode; 6: index of old opcode
1315 break;
1316 }
1317 case OldBytecodeInst::Opcode::ECMA_STSUPERBYNAME_PREF_ID32_V8: {
1318 newOpcode = EcmaOpcode::STSUPERBYNAME_IMM8_ID16_V8;
1319 uint32_t id = inst.GetId();
1320 LOG_ECMA_IF(id > std::numeric_limits<uint16_t>::max(), FATAL) << "Cannot translate to 16 bits: " << id;
1321 *pc = static_cast<uint8_t>(newOpcode);
1322 *(pc + 1) = 0x00;
1323 uint16_t newId = static_cast<uint16_t>(id);
1324 if (memcpy_s(pc + 2, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { // 2: skip opcode and ic slot
1325 LOG_FULL(FATAL) << "FixOpcode memcpy_s fail";
1326 UNREACHABLE();
1327 }
1328 *(pc + 4) = *(pc + 6); // 4: index of new opcode; 6: index of old opcode
1329 break;
1330 }
1331 case OldBytecodeInst::Opcode::ECMA_STOWNBYNAMEWITHNAMESET_PREF_ID32_V8: {
1332 newOpcode = EcmaOpcode::STOWNBYNAMEWITHNAMESET_IMM8_ID16_V8;
1333 uint32_t id = inst.GetId();
1334 LOG_ECMA_IF(id > std::numeric_limits<uint16_t>::max(), FATAL) << "Cannot translate to 16 bits: " << id;
1335 *pc = static_cast<uint8_t>(newOpcode);
1336 *(pc + 1) = 0x00;
1337 uint16_t newId = static_cast<uint16_t>(id);
1338 if (memcpy_s(pc + 2, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { // 2: skip opcode and ic slot
1339 LOG_FULL(FATAL) << "FixOpcode memcpy_s fail";
1340 UNREACHABLE();
1341 }
1342 *(pc + 4) = *(pc + 6); // 4: index of new opcode; 6: index of old opcode
1343 break;
1344 }
1345 case OldBytecodeInst::Opcode::ECMA_CREATEREGEXPWITHLITERAL_PREF_ID32_IMM8: {
1346 newOpcode = EcmaOpcode::CREATEREGEXPWITHLITERAL_IMM8_ID16_IMM8;
1347 uint32_t id = inst.GetId();
1348 LOG_ECMA_IF(id > std::numeric_limits<uint16_t>::max(), FATAL) << "Cannot translate to 16 bits: " << id;
1349 *pc = static_cast<uint8_t>(newOpcode);
1350 *(pc + 1) = 0x00;
1351 uint16_t newId = static_cast<uint16_t>(id);
1352 if (memcpy_s(pc + 2, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { // 2: skip opcode and ic slot
1353 LOG_FULL(FATAL) << "FixOpcode memcpy_s fail";
1354 UNREACHABLE();
1355 }
1356 *(pc + 4) = *(pc + 6); // 4: index of new opcode; 6: index of old opcode
1357 break;
1358 }
1359 // ID32 to ID16 no IC (PREF_ID32)
1360 case OldBytecodeInst::Opcode::ECMA_LDBIGINT_PREF_ID32: {
1361 newOpcode = EcmaOpcode::LDBIGINT_ID16;
1362 uint32_t id = inst.GetId();
1363 LOG_ECMA_IF(id > std::numeric_limits<uint16_t>::max(), FATAL) << "Cannot translate to 16 bits: " << id;
1364 *pc = static_cast<uint8_t>(newOpcode);
1365 uint16_t newId = static_cast<uint16_t>(id);
1366 if (memcpy_s(pc + 1, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) {
1367 LOG_FULL(FATAL) << "FixOpcode memcpy_s fail";
1368 UNREACHABLE();
1369 }
1370 break;
1371 }
1372 // Translate to other first level opcode
1373 case OldBytecodeInst::Opcode::ECMA_NEWOBJSPREADDYN_PREF_V8_V8: {
1374 newOpcode = EcmaOpcode::NEWOBJAPPLY_IMM8_V8;
1375 *pc = static_cast<uint8_t>(newOpcode);
1376 *(pc + 1) = 0x00;
1377 *(pc + 2) = *(pc + 3); // 2 & 3: skip newtarget, so move vreg1 to vreg0
1378 break;
1379 }
1380 case OldBytecodeInst::Opcode::ECMA_LDGLOBALVAR_PREF_ID32: {
1381 newOpcode = EcmaOpcode::LDGLOBALVAR_IMM16_ID16;
1382 uint32_t id = inst.GetId();
1383 LOG_ECMA_IF(id > std::numeric_limits<uint16_t>::max(), FATAL) << "Cannot translate to 16 bits: " << id;
1384 *pc = static_cast<uint8_t>(newOpcode);
1385 *(pc + 1) = 0x00;
1386 *(pc + 2) = 0x00; // 2: offset of id
1387 uint16_t newId = static_cast<uint16_t>(id);
1388 if (memcpy_s(pc + 3, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { // 3: offset of id
1389 LOG_FULL(FATAL) << "FixOpcode memcpy_s fail";
1390 UNREACHABLE();
1391 }
1392 break;
1393 }
1394 case OldBytecodeInst::Opcode::ECMA_STGLOBALVAR_PREF_ID32: {
1395 newOpcode = EcmaOpcode::STGLOBALVAR_IMM16_ID16;
1396 uint32_t id = inst.GetId();
1397 LOG_ECMA_IF(id > std::numeric_limits<uint16_t>::max(), FATAL) << "Cannot translate to 16 bits: " << id;
1398 *pc = static_cast<uint8_t>(newOpcode);
1399 *(pc + 1) = 0x00;
1400 *(pc + 2) = 0x00; // 2: offset of id
1401 uint16_t newId = static_cast<uint16_t>(id);
1402 if (memcpy_s(pc + 3, sizeof(uint16_t), &newId, sizeof(uint16_t)) != EOK) { // 3: offset of id
1403 LOG_FULL(FATAL) << "FixOpcode memcpy_s fail";
1404 UNREACHABLE();
1405 }
1406 break;
1407 }
1408 case OldBytecodeInst::Opcode::ECMA_DEFINEMETHOD_PREF_ID16_IMM16_V8: {
1409 newOpcode = EcmaOpcode::DEFINEMETHOD_IMM8_ID16_IMM8;
1410 *pc = static_cast<uint8_t>(newOpcode);
1411 uint16_t imm = static_cast<uint16_t>(inst.GetImm<OldBytecodeInst::Format::PREF_ID16_IMM16_V8>());
1412 uint8_t newImm = static_cast<uint8_t>(imm);
1413 if (memcpy_s(pc + 4, sizeof(uint8_t), &newImm, sizeof(uint8_t)) != EOK) { // 4: offset of imm
1414 LOG_FULL(FATAL) << "FixOpcode memcpy_s fail";
1415 UNREACHABLE();
1416 }
1417 break;
1418 }
1419 case OldBytecodeInst::Opcode::ECMA_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8:
1420 U_FALLTHROUGH;
1421 case OldBytecodeInst::Opcode::ECMA_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8:
1422 U_FALLTHROUGH;
1423 case OldBytecodeInst::Opcode::ECMA_DEFINENCFUNCDYN_PREF_ID16_IMM16_V8:
1424 U_FALLTHROUGH;
1425 case OldBytecodeInst::Opcode::ECMA_DEFINEFUNCDYN_PREF_ID16_IMM16_V8:
1426 U_FALLTHROUGH;
1427 case OldBytecodeInst::Opcode::ECMA_DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8: {
1428 newOpcode = EcmaOpcode::DEFINEFUNC_IMM8_ID16_IMM8;
1429 *pc = static_cast<uint8_t>(newOpcode);
1430 uint16_t imm = static_cast<uint16_t>(inst.GetImm<OldBytecodeInst::Format::PREF_ID16_IMM16_V8>());
1431 uint8_t newImm = static_cast<uint8_t>(imm);
1432 if (memcpy_s(pc + 4, sizeof(uint8_t), &newImm, sizeof(uint8_t)) != EOK) { // 4: offset of imm
1433 LOG_FULL(FATAL) << "FixOpcode memcpy_s fail";
1434 UNREACHABLE();
1435 }
1436 break;
1437 }
1438 default:
1439 LOG_FULL(FATAL) << "Is not an Ecma Opcode opcode: " << static_cast<uint32_t>(opcode);
1440 UNREACHABLE();
1441 break;
1442 }
1443 ADD_NOP_INST(pc, oldLen, newOpcode);
1444 UpdateICOffset(method, pc);
1445 }
1446
1447 // reuse prefix 8bits to store slotid
UpdateICOffset(MethodLiteral *methodLiteral, uint8_t *pc)1448 void PandaFileTranslator::UpdateICOffset(MethodLiteral *methodLiteral, uint8_t *pc)
1449 {
1450 uint8_t offset = MethodLiteral::INVALID_IC_SLOT;
1451 BytecodeInstruction inst(pc);
1452 auto opcode = inst.GetOpcode();
1453 switch (opcode) {
1454 case EcmaOpcode::TRYLDGLOBALBYNAME_IMM8_ID16:
1455 U_FALLTHROUGH;
1456 case EcmaOpcode::TRYSTGLOBALBYNAME_IMM8_ID16:
1457 U_FALLTHROUGH;
1458 case EcmaOpcode::LDGLOBALVAR_IMM16_ID16:
1459 U_FALLTHROUGH;
1460 case EcmaOpcode::STGLOBALVAR_IMM16_ID16:
1461 offset = methodLiteral->UpdateSlotSizeWith8Bit(1);
1462 break;
1463 case EcmaOpcode::INSTANCEOF_IMM8_V8:
1464 U_FALLTHROUGH;
1465 case EcmaOpcode::STOBJBYVALUE_IMM8_V8_V8:
1466 U_FALLTHROUGH;
1467 case EcmaOpcode::STOWNBYVALUE_IMM8_V8_V8:
1468 U_FALLTHROUGH;
1469 case EcmaOpcode::STOBJBYNAME_IMM8_ID16_V8:
1470 U_FALLTHROUGH;
1471 case EcmaOpcode::STOWNBYNAME_IMM8_ID16_V8:
1472 U_FALLTHROUGH;
1473 case EcmaOpcode::STSUPERBYVALUE_IMM8_V8_V8:
1474 U_FALLTHROUGH;
1475 case EcmaOpcode::STSUPERBYNAME_IMM8_ID16_V8:
1476 offset = methodLiteral->UpdateSlotSizeWith8Bit(2); // 2: occupy two ic slot
1477 break;
1478 default:
1479 return;
1480 }
1481
1482 if (opcode == EcmaOpcode::LDGLOBALVAR_IMM16_ID16 || opcode == EcmaOpcode::STGLOBALVAR_IMM16_ID16) {
1483 uint16_t icSlot = static_cast<uint16_t>(offset);
1484 if (memcpy_s(pc + 1, sizeof(uint16_t), &icSlot, sizeof(uint16_t)) != EOK) {
1485 LOG_FULL(FATAL) << "UpdateICOffset memcpy_s fail";
1486 UNREACHABLE();
1487 }
1488 } else {
1489 *(pc + 1) = offset;
1490 }
1491 }
1492
FixInstructionId32(const OldBytecodeInst &inst, uint32_t index, uint32_t fixOrder)1493 void PandaFileTranslator::FixInstructionId32(const OldBytecodeInst &inst, uint32_t index, uint32_t fixOrder)
1494 {
1495 // NOLINTNEXTLINE(hicpp-use-auto)
1496 auto pc = const_cast<uint8_t *>(inst.GetAddress());
1497 switch (OldBytecodeInst::GetFormat(inst.GetOpcode())) {
1498 case OldBytecodeInst::Format::ID32: {
1499 uint8_t size = sizeof(uint32_t);
1500 // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
1501 if (memcpy_s(pc + FixInstructionIndex::FIX_ONE, size, &index, size) != EOK) {
1502 LOG_FULL(FATAL) << "memcpy_s failed";
1503 UNREACHABLE();
1504 }
1505 break;
1506 }
1507 case OldBytecodeInst::Format::PREF_ID16_IMM16_V8: {
1508 uint16_t u16Index = index;
1509 uint8_t size = sizeof(uint16_t);
1510 // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
1511 if (memcpy_s(pc + FixInstructionIndex::FIX_TWO, size, &u16Index, size) != EOK) {
1512 LOG_FULL(FATAL) << "memcpy_s failed";
1513 UNREACHABLE();
1514 }
1515 break;
1516 }
1517 case OldBytecodeInst::Format::PREF_ID32:
1518 U_FALLTHROUGH;
1519 case OldBytecodeInst::Format::PREF_ID32_V8:
1520 U_FALLTHROUGH;
1521 case OldBytecodeInst::Format::PREF_ID32_IMM8: {
1522 uint8_t size = sizeof(uint32_t);
1523 // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
1524 if (memcpy_s(pc + FixInstructionIndex::FIX_TWO, size, &index, size) != EOK) {
1525 LOG_FULL(FATAL) << "memcpy_s failed";
1526 UNREACHABLE();
1527 }
1528 break;
1529 }
1530 case OldBytecodeInst::Format::PREF_IMM16: {
1531 ASSERT(static_cast<uint16_t>(index) == index);
1532 uint16_t u16Index = index;
1533 uint8_t size = sizeof(uint16_t);
1534 // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
1535 if (memcpy_s(pc + FixInstructionIndex::FIX_TWO, size, &u16Index, size) != EOK) {
1536 LOG_FULL(FATAL) << "memcpy_s failed";
1537 UNREACHABLE();
1538 }
1539 break;
1540 }
1541 case OldBytecodeInst::Format::PREF_ID16_IMM16_IMM16_V8_V8: {
1542 // Usually, we fix one part of instruction one time. But as for instruction DefineClassWithBuffer,
1543 // which use both method id and literal buffer id.Using fixOrder indicates fix Location.
1544 if (fixOrder == 0) {
1545 uint8_t size = sizeof(uint16_t);
1546 ASSERT(static_cast<uint16_t>(index) == index);
1547 // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
1548 if (memcpy_s(pc + FixInstructionIndex::FIX_TWO, size, &index, size) != EOK) {
1549 LOG_FULL(FATAL) << "memcpy_s failed";
1550 UNREACHABLE();
1551 }
1552 break;
1553 }
1554 if (fixOrder == 1) {
1555 ASSERT(static_cast<uint16_t>(index) == index);
1556 uint16_t u16Index = index;
1557 uint8_t size = sizeof(uint16_t);
1558 // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
1559 if (memcpy_s(pc + FixInstructionIndex::FIX_FOUR, size, &u16Index, size) != EOK) {
1560 LOG_FULL(FATAL) << "memcpy_s failed";
1561 UNREACHABLE();
1562 }
1563 break;
1564 }
1565 break;
1566 }
1567 default:
1568 LOG_ECMA(FATAL) << "this branch is unreachable";
1569 UNREACHABLE();
1570 }
1571 }
1572
TranslateBytecode(JSPandaFile *jsPandaFile, uint32_t insSz, const uint8_t *insArr, const MethodLiteral *method, const CString &entryPoint)1573 void PandaFileTranslator::TranslateBytecode(JSPandaFile *jsPandaFile, uint32_t insSz, const uint8_t *insArr,
1574 const MethodLiteral *method, const CString &entryPoint)
1575 {
1576 auto bcIns = OldBytecodeInst(insArr);
1577 auto bcInsLast = bcIns.JumpTo(insSz);
1578 const CUnorderedMap<uint32_t, uint64_t> *ConstpoolMap = jsPandaFile->GetConstpoolMapByReocrd(entryPoint);
1579 while (bcIns.GetAddress() != bcInsLast.GetAddress()) {
1580 if (bcIns.HasFlag(OldBytecodeInst::Flags::STRING_ID) &&
1581 OldBytecodeInst::HasId(OldBytecodeInst::GetFormat(bcIns.GetOpcode()), 0)) {
1582 auto index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::STRING, bcIns.GetId());
1583 FixInstructionId32(bcIns, index);
1584 } else {
1585 OldBytecodeInst::Opcode opcode = static_cast<OldBytecodeInst::Opcode>(bcIns.GetOpcode());
1586 switch (opcode) {
1587 uint32_t index;
1588 uint32_t methodId;
1589 case OldBytecodeInst::Opcode::ECMA_DEFINEFUNCDYN_PREF_ID16_IMM16_V8:
1590 methodId = jsPandaFile->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId()).GetOffset();
1591 index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::BASE_FUNCTION, methodId, ConstpoolMap);
1592 FixInstructionId32(bcIns, index);
1593 break;
1594 case OldBytecodeInst::Opcode::ECMA_DEFINENCFUNCDYN_PREF_ID16_IMM16_V8:
1595 methodId = jsPandaFile->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId()).GetOffset();
1596 index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::NC_FUNCTION, methodId, ConstpoolMap);
1597 FixInstructionId32(bcIns, index);
1598 break;
1599 case OldBytecodeInst::Opcode::ECMA_DEFINEGENERATORFUNC_PREF_ID16_IMM16_V8:
1600 methodId = jsPandaFile->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId()).GetOffset();
1601 index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::GENERATOR_FUNCTION, methodId,
1602 ConstpoolMap);
1603 FixInstructionId32(bcIns, index);
1604 break;
1605 case OldBytecodeInst::Opcode::ECMA_DEFINEASYNCGENERATORFUNC_PREF_ID16_IMM16_V8:
1606 methodId = jsPandaFile->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId()).GetOffset();
1607 index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::ASYNC_GENERATOR_FUNCTION, methodId,
1608 ConstpoolMap);
1609 FixInstructionId32(bcIns, index);
1610 break;
1611 case OldBytecodeInst::Opcode::ECMA_DEFINEASYNCFUNC_PREF_ID16_IMM16_V8:
1612 methodId = jsPandaFile->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId()).GetOffset();
1613 index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::ASYNC_FUNCTION, methodId, ConstpoolMap);
1614 FixInstructionId32(bcIns, index);
1615 break;
1616 case OldBytecodeInst::Opcode::ECMA_DEFINEMETHOD_PREF_ID16_IMM16_V8:
1617 methodId = jsPandaFile->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId()).GetOffset();
1618 index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::METHOD, methodId, ConstpoolMap);
1619 FixInstructionId32(bcIns, index);
1620 break;
1621 case OldBytecodeInst::Opcode::ECMA_CREATEOBJECTWITHBUFFER_PREF_IMM16:
1622 U_FALLTHROUGH;
1623 case OldBytecodeInst::Opcode::ECMA_CREATEOBJECTHAVINGMETHOD_PREF_IMM16: {
1624 auto imm = bcIns.GetImm<OldBytecodeInst::Format::PREF_IMM16>();
1625 index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::OBJECT_LITERAL,
1626 static_cast<uint16_t>(imm), ConstpoolMap);
1627 FixInstructionId32(bcIns, index);
1628 break;
1629 }
1630 case OldBytecodeInst::Opcode::ECMA_CREATEARRAYWITHBUFFER_PREF_IMM16: {
1631 auto imm = bcIns.GetImm<OldBytecodeInst::Format::PREF_IMM16>();
1632 index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::ARRAY_LITERAL,
1633 static_cast<uint16_t>(imm), ConstpoolMap);
1634 FixInstructionId32(bcIns, index);
1635 break;
1636 }
1637 case OldBytecodeInst::Opcode::ECMA_DEFINECLASSWITHBUFFER_PREF_ID16_IMM16_IMM16_V8_V8: {
1638 methodId = jsPandaFile->ResolveMethodIndex(method->GetMethodId(), bcIns.GetId()).GetOffset();
1639 index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::CLASS_FUNCTION, methodId, ConstpoolMap);
1640 FixInstructionId32(bcIns, index);
1641 auto imm = bcIns.GetImm<OldBytecodeInst::Format::PREF_ID16_IMM16_IMM16_V8_V8>();
1642 index = jsPandaFile->GetOrInsertConstantPool(ConstPoolType::CLASS_LITERAL,
1643 static_cast<uint16_t>(imm), ConstpoolMap);
1644 FixInstructionId32(bcIns, index, 1);
1645 break;
1646 }
1647 default:
1648 break;
1649 }
1650 }
1651 // NOLINTNEXTLINE(hicpp-use-auto)
1652 auto nextInst = bcIns.GetNext();
1653 FixOpcode(const_cast<MethodLiteral *>(method), bcIns);
1654 bcIns = nextInst;
1655 }
1656 }
1657 } // namespace panda::ecmascript
1658