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