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 22namespace panda::ecmascript { 23using EcmaOpcode = kungfu::EcmaOpcode; 24 25template<class T, class... Args> 26static T *InitializeMemory(T *mem, Args... args) 27{ 28 return new (mem) T(std::forward<Args>(args)...); 29} 30 31void 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 96void 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 139JSHandle<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 174JSHandle<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 206std::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 278void 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 349JSHandle<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 360JSHandle<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) \ 371do { \ 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 379void 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 1448void 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 1493void 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 1573void 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