Interpreter.cpp 69 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727
  1. /*
  2. * Copyright (c) 2021, Andreas Kling <kling@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/Debug.h>
  7. #include <AK/HashTable.h>
  8. #include <AK/TemporaryChange.h>
  9. #include <LibJS/AST.h>
  10. #include <LibJS/Bytecode/BasicBlock.h>
  11. #include <LibJS/Bytecode/CommonImplementations.h>
  12. #include <LibJS/Bytecode/Generator.h>
  13. #include <LibJS/Bytecode/Instruction.h>
  14. #include <LibJS/Bytecode/Interpreter.h>
  15. #include <LibJS/Bytecode/Label.h>
  16. #include <LibJS/Bytecode/Op.h>
  17. #include <LibJS/JIT/Compiler.h>
  18. #include <LibJS/JIT/NativeExecutable.h>
  19. #include <LibJS/Runtime/AbstractOperations.h>
  20. #include <LibJS/Runtime/Array.h>
  21. #include <LibJS/Runtime/BigInt.h>
  22. #include <LibJS/Runtime/DeclarativeEnvironment.h>
  23. #include <LibJS/Runtime/ECMAScriptFunctionObject.h>
  24. #include <LibJS/Runtime/Environment.h>
  25. #include <LibJS/Runtime/FunctionEnvironment.h>
  26. #include <LibJS/Runtime/GlobalEnvironment.h>
  27. #include <LibJS/Runtime/GlobalObject.h>
  28. #include <LibJS/Runtime/Iterator.h>
  29. #include <LibJS/Runtime/NativeFunction.h>
  30. #include <LibJS/Runtime/ObjectEnvironment.h>
  31. #include <LibJS/Runtime/Realm.h>
  32. #include <LibJS/Runtime/Reference.h>
  33. #include <LibJS/Runtime/RegExpObject.h>
  34. #include <LibJS/Runtime/Value.h>
  35. #include <LibJS/Runtime/ValueInlines.h>
  36. #include <LibJS/SourceTextModule.h>
  37. namespace JS::Bytecode {
  38. bool g_dump_bytecode = false;
  39. Interpreter::Interpreter(VM& vm)
  40. : m_vm(vm)
  41. {
  42. }
  43. Interpreter::~Interpreter()
  44. {
  45. }
  46. void Interpreter::visit_edges(Cell::Visitor& visitor)
  47. {
  48. for (auto& frame : m_call_frames) {
  49. frame.visit([&](auto& value) { value->visit_edges(visitor); });
  50. }
  51. }
  52. // 16.1.6 ScriptEvaluation ( scriptRecord ), https://tc39.es/ecma262/#sec-runtime-semantics-scriptevaluation
  53. ThrowCompletionOr<Value> Interpreter::run(Script& script_record, JS::GCPtr<Environment> lexical_environment_override)
  54. {
  55. auto& vm = this->vm();
  56. // 1. Let globalEnv be scriptRecord.[[Realm]].[[GlobalEnv]].
  57. auto& global_environment = script_record.realm().global_environment();
  58. // 2. Let scriptContext be a new ECMAScript code execution context.
  59. ExecutionContext script_context(vm.heap());
  60. // 3. Set the Function of scriptContext to null.
  61. // NOTE: This was done during execution context construction.
  62. // 4. Set the Realm of scriptContext to scriptRecord.[[Realm]].
  63. script_context.realm = &script_record.realm();
  64. // 5. Set the ScriptOrModule of scriptContext to scriptRecord.
  65. script_context.script_or_module = NonnullGCPtr<Script>(script_record);
  66. // 6. Set the VariableEnvironment of scriptContext to globalEnv.
  67. script_context.variable_environment = &global_environment;
  68. // 7. Set the LexicalEnvironment of scriptContext to globalEnv.
  69. script_context.lexical_environment = &global_environment;
  70. // Non-standard: Override the lexical environment if requested.
  71. if (lexical_environment_override)
  72. script_context.lexical_environment = lexical_environment_override;
  73. // 8. Set the PrivateEnvironment of scriptContext to null.
  74. // NOTE: This isn't in the spec, but we require it.
  75. script_context.is_strict_mode = script_record.parse_node().is_strict_mode();
  76. // FIXME: 9. Suspend the currently running execution context.
  77. // 10. Push scriptContext onto the execution context stack; scriptContext is now the running execution context.
  78. TRY(vm.push_execution_context(script_context, {}));
  79. // 11. Let script be scriptRecord.[[ECMAScriptCode]].
  80. auto& script = script_record.parse_node();
  81. // 12. Let result be Completion(GlobalDeclarationInstantiation(script, globalEnv)).
  82. auto instantiation_result = script.global_declaration_instantiation(vm, global_environment);
  83. Completion result = instantiation_result.is_throw_completion() ? instantiation_result.throw_completion() : normal_completion({});
  84. // 13. If result.[[Type]] is normal, then
  85. if (result.type() == Completion::Type::Normal) {
  86. auto executable_result = JS::Bytecode::Generator::generate(script);
  87. if (executable_result.is_error()) {
  88. if (auto error_string = executable_result.error().to_string(); error_string.is_error())
  89. result = vm.template throw_completion<JS::InternalError>(vm.error_message(JS::VM::ErrorMessage::OutOfMemory));
  90. else if (error_string = String::formatted("TODO({})", error_string.value()); error_string.is_error())
  91. result = vm.template throw_completion<JS::InternalError>(vm.error_message(JS::VM::ErrorMessage::OutOfMemory));
  92. else
  93. result = JS::throw_completion(JS::InternalError::create(realm(), error_string.release_value()));
  94. } else {
  95. auto executable = executable_result.release_value();
  96. if (g_dump_bytecode)
  97. executable->dump();
  98. // a. Set result to the result of evaluating script.
  99. auto result_or_error = run_and_return_frame(*executable, nullptr);
  100. if (result_or_error.value.is_error())
  101. result = result_or_error.value.release_error();
  102. else
  103. result = result_or_error.frame->registers[0];
  104. }
  105. }
  106. // 14. If result.[[Type]] is normal and result.[[Value]] is empty, then
  107. if (result.type() == Completion::Type::Normal && !result.value().has_value()) {
  108. // a. Set result to NormalCompletion(undefined).
  109. result = normal_completion(js_undefined());
  110. }
  111. // FIXME: 15. Suspend scriptContext and remove it from the execution context stack.
  112. vm.pop_execution_context();
  113. // 16. Assert: The execution context stack is not empty.
  114. VERIFY(!vm.execution_context_stack().is_empty());
  115. // FIXME: 17. Resume the context that is now on the top of the execution context stack as the running execution context.
  116. // At this point we may have already run any queued promise jobs via on_call_stack_emptied,
  117. // in which case this is a no-op.
  118. // FIXME: These three should be moved out of Interpreter::run and give the host an option to run these, as it's up to the host when these get run.
  119. // https://tc39.es/ecma262/#sec-jobs for jobs and https://tc39.es/ecma262/#_ref_3508 for ClearKeptObjects
  120. // finish_execution_generation is particularly an issue for LibWeb, as the HTML spec wants to run it specifically after performing a microtask checkpoint.
  121. // The promise and registry cleanup queues don't cause LibWeb an issue, as LibWeb overrides the hooks that push onto these queues.
  122. vm.run_queued_promise_jobs();
  123. vm.run_queued_finalization_registry_cleanup_jobs();
  124. vm.finish_execution_generation();
  125. // 18. Return ? result.
  126. if (result.is_abrupt()) {
  127. VERIFY(result.type() == Completion::Type::Throw);
  128. return result.release_error();
  129. }
  130. VERIFY(result.value().has_value());
  131. return *result.value();
  132. }
  133. ThrowCompletionOr<Value> Interpreter::run(SourceTextModule& module)
  134. {
  135. // FIXME: This is not a entry point as defined in the spec, but is convenient.
  136. // To avoid work we use link_and_eval_module however that can already be
  137. // dangerous if the vm loaded other modules.
  138. auto& vm = this->vm();
  139. TRY(vm.link_and_eval_module(Badge<Bytecode::Interpreter> {}, module));
  140. vm.run_queued_promise_jobs();
  141. vm.run_queued_finalization_registry_cleanup_jobs();
  142. return js_undefined();
  143. }
  144. void Interpreter::run_bytecode()
  145. {
  146. auto* locals = vm().running_execution_context().local_variables.data();
  147. auto* registers = this->registers().data();
  148. auto& accumulator = this->accumulator();
  149. for (;;) {
  150. start:
  151. auto pc = InstructionStreamIterator { m_current_block->instruction_stream(), m_current_executable };
  152. TemporaryChange temp_change { m_pc, Optional<InstructionStreamIterator&>(pc) };
  153. bool will_return = false;
  154. bool will_yield = false;
  155. ThrowCompletionOr<void> result;
  156. while (!pc.at_end()) {
  157. auto& instruction = *pc;
  158. switch (instruction.type()) {
  159. case Instruction::Type::GetLocal: {
  160. auto& local = locals[static_cast<Op::GetLocal const&>(instruction).index()];
  161. if (local.is_empty()) {
  162. auto const& variable_name = vm().running_execution_context().function->local_variables_names()[static_cast<Op::GetLocal const&>(instruction).index()];
  163. result = vm().throw_completion<ReferenceError>(ErrorType::BindingNotInitialized, variable_name);
  164. break;
  165. }
  166. accumulator = local;
  167. break;
  168. }
  169. case Instruction::Type::SetLocal:
  170. locals[static_cast<Op::SetLocal const&>(instruction).index()] = accumulator;
  171. break;
  172. case Instruction::Type::Load:
  173. accumulator = registers[static_cast<Op::Load const&>(instruction).src().index()];
  174. break;
  175. case Instruction::Type::Store:
  176. registers[static_cast<Op::Store const&>(instruction).dst().index()] = accumulator;
  177. break;
  178. case Instruction::Type::LoadImmediate:
  179. accumulator = static_cast<Op::LoadImmediate const&>(instruction).value();
  180. break;
  181. case Instruction::Type::Jump:
  182. m_current_block = &static_cast<Op::Jump const&>(instruction).true_target()->block();
  183. goto start;
  184. case Instruction::Type::JumpConditional:
  185. if (accumulator.to_boolean())
  186. m_current_block = &static_cast<Op::Jump const&>(instruction).true_target()->block();
  187. else
  188. m_current_block = &static_cast<Op::Jump const&>(instruction).false_target()->block();
  189. goto start;
  190. case Instruction::Type::JumpNullish:
  191. if (accumulator.is_nullish())
  192. m_current_block = &static_cast<Op::Jump const&>(instruction).true_target()->block();
  193. else
  194. m_current_block = &static_cast<Op::Jump const&>(instruction).false_target()->block();
  195. goto start;
  196. case Instruction::Type::JumpUndefined:
  197. if (accumulator.is_undefined())
  198. m_current_block = &static_cast<Op::Jump const&>(instruction).true_target()->block();
  199. else
  200. m_current_block = &static_cast<Op::Jump const&>(instruction).false_target()->block();
  201. goto start;
  202. case Instruction::Type::EnterUnwindContext:
  203. enter_unwind_context();
  204. m_current_block = &static_cast<Op::EnterUnwindContext const&>(instruction).entry_point().block();
  205. goto start;
  206. case Instruction::Type::ContinuePendingUnwind: {
  207. if (auto exception = reg(Register::exception()); !exception.is_empty()) {
  208. result = throw_completion(exception);
  209. break;
  210. }
  211. if (!saved_return_value().is_empty()) {
  212. do_return(saved_return_value());
  213. break;
  214. }
  215. auto const* old_scheduled_jump = call_frame().previously_scheduled_jumps.take_last();
  216. if (m_scheduled_jump) {
  217. // FIXME: If we `break` or `continue` in the finally, we need to clear
  218. // this field
  219. // Same goes for popping an old_scheduled_jump form the stack
  220. m_current_block = exchange(m_scheduled_jump, nullptr);
  221. } else {
  222. m_current_block = &static_cast<Op::ContinuePendingUnwind const&>(instruction).resume_target().block();
  223. // set the scheduled jump to the old value if we continue
  224. // where we left it
  225. m_scheduled_jump = old_scheduled_jump;
  226. }
  227. goto start;
  228. }
  229. case Instruction::Type::ScheduleJump: {
  230. m_scheduled_jump = &static_cast<Op::ScheduleJump const&>(instruction).target().block();
  231. auto const* finalizer = m_current_block->finalizer();
  232. VERIFY(finalizer);
  233. m_current_block = finalizer;
  234. goto start;
  235. }
  236. default:
  237. result = instruction.execute(*this);
  238. break;
  239. }
  240. if (result.is_error()) [[unlikely]] {
  241. reg(Register::exception()) = *result.throw_completion().value();
  242. m_scheduled_jump = {};
  243. auto const* handler = m_current_block->handler();
  244. auto const* finalizer = m_current_block->finalizer();
  245. if (!handler && !finalizer)
  246. return;
  247. auto& unwind_context = unwind_contexts().last();
  248. VERIFY(unwind_context.executable == m_current_executable);
  249. if (handler) {
  250. VERIFY(!unwind_context.handler_called);
  251. vm().running_execution_context().lexical_environment = unwind_context.lexical_environment;
  252. m_current_block = handler;
  253. unwind_context.handler_called = true;
  254. accumulator = reg(Register::exception());
  255. reg(Register::exception()) = {};
  256. goto start;
  257. }
  258. if (finalizer) {
  259. m_current_block = finalizer;
  260. // If an exception was thrown inside the corresponding `catch` block, we need to rethrow it
  261. // from the `finally` block. But if the exception is from the `try` block, and has already been
  262. // handled by `catch`, we swallow it.
  263. if (!unwind_context.handler_called)
  264. reg(Register::exception()) = {};
  265. goto start;
  266. }
  267. // An unwind context with no handler or finalizer? We have nowhere to jump, and continuing on will make us crash on the next `Call` to a non-native function if there's an exception! So let's crash here instead.
  268. // If you run into this, you probably forgot to remove the current unwind_context somewhere.
  269. VERIFY_NOT_REACHED();
  270. }
  271. if (!reg(Register::return_value()).is_empty()) {
  272. will_return = true;
  273. // Note: A `yield` statement will not go through a finally statement,
  274. // hence we need to set a flag to not do so,
  275. // but we generate a Yield Operation in the case of returns in
  276. // generators as well, so we need to check if it will actually
  277. // continue or is a `return` in disguise
  278. will_yield = (instruction.type() == Instruction::Type::Yield && static_cast<Op::Yield const&>(instruction).continuation().has_value()) || instruction.type() == Instruction::Type::Await;
  279. break;
  280. }
  281. ++pc;
  282. }
  283. if (auto const* finalizer = m_current_block->finalizer(); finalizer && !will_yield) {
  284. auto& unwind_context = unwind_contexts().last();
  285. VERIFY(unwind_context.executable == m_current_executable);
  286. reg(Register::saved_return_value()) = reg(Register::return_value());
  287. reg(Register::return_value()) = {};
  288. m_current_block = finalizer;
  289. // the unwind_context will be pop'ed when entering the finally block
  290. continue;
  291. }
  292. if (pc.at_end())
  293. break;
  294. if (will_return)
  295. break;
  296. }
  297. }
  298. Interpreter::ValueAndFrame Interpreter::run_and_return_frame(Executable& executable, BasicBlock const* entry_point, CallFrame* in_frame)
  299. {
  300. dbgln_if(JS_BYTECODE_DEBUG, "Bytecode::Interpreter will run unit {:p}", &executable);
  301. TemporaryChange restore_executable { m_current_executable, &executable };
  302. TemporaryChange restore_saved_jump { m_scheduled_jump, static_cast<BasicBlock const*>(nullptr) };
  303. VERIFY(!vm().execution_context_stack().is_empty());
  304. TemporaryChange restore_current_block { m_current_block, entry_point ?: executable.basic_blocks.first() };
  305. if (in_frame)
  306. push_call_frame(in_frame, executable.number_of_registers);
  307. else
  308. push_call_frame(make<CallFrame>(), executable.number_of_registers);
  309. vm().execution_context_stack().last()->executable = &executable;
  310. if (auto native_executable = executable.get_or_create_native_executable()) {
  311. auto block_index = 0;
  312. if (entry_point)
  313. block_index = executable.basic_blocks.find_first_index_if([&](auto const& block) { return block.ptr() == entry_point; }).value();
  314. native_executable->run(vm(), block_index);
  315. #if 0
  316. for (size_t i = 0; i < vm().running_execution_context().local_variables.size(); ++i) {
  317. dbgln("%{}: {}", i, vm().running_execution_context().local_variables[i]);
  318. }
  319. #endif
  320. } else {
  321. run_bytecode();
  322. }
  323. dbgln_if(JS_BYTECODE_DEBUG, "Bytecode::Interpreter did run unit {:p}", &executable);
  324. if constexpr (JS_BYTECODE_DEBUG) {
  325. for (size_t i = 0; i < registers().size(); ++i) {
  326. String value_string;
  327. if (registers()[i].is_empty())
  328. value_string = "(empty)"_string;
  329. else
  330. value_string = registers()[i].to_string_without_side_effects();
  331. dbgln("[{:3}] {}", i, value_string);
  332. }
  333. }
  334. auto return_value = js_undefined();
  335. if (!reg(Register::return_value()).is_empty())
  336. return_value = reg(Register::return_value());
  337. else if (!reg(Register::saved_return_value()).is_empty())
  338. return_value = reg(Register::saved_return_value());
  339. auto exception = reg(Register::exception());
  340. auto frame = pop_call_frame();
  341. // NOTE: The return value from a called function is put into $0 in the caller context.
  342. if (!m_call_frames.is_empty())
  343. call_frame().registers[0] = return_value;
  344. // At this point we may have already run any queued promise jobs via on_call_stack_emptied,
  345. // in which case this is a no-op.
  346. vm().run_queued_promise_jobs();
  347. vm().finish_execution_generation();
  348. if (!exception.is_empty()) {
  349. if (auto* call_frame = frame.get_pointer<NonnullOwnPtr<CallFrame>>())
  350. return { throw_completion(exception), move(*call_frame) };
  351. return { throw_completion(exception), nullptr };
  352. }
  353. if (auto* call_frame = frame.get_pointer<NonnullOwnPtr<CallFrame>>())
  354. return { return_value, move(*call_frame) };
  355. return { return_value, nullptr };
  356. }
  357. void Interpreter::enter_unwind_context()
  358. {
  359. unwind_contexts().empend(
  360. m_current_executable,
  361. vm().running_execution_context().lexical_environment);
  362. call_frame().previously_scheduled_jumps.append(m_scheduled_jump);
  363. m_scheduled_jump = nullptr;
  364. }
  365. void Interpreter::leave_unwind_context()
  366. {
  367. unwind_contexts().take_last();
  368. }
  369. ThrowCompletionOr<NonnullRefPtr<Bytecode::Executable>> compile(VM& vm, ASTNode const& node, FunctionKind kind, DeprecatedFlyString const& name)
  370. {
  371. auto executable_result = Bytecode::Generator::generate(node, kind);
  372. if (executable_result.is_error())
  373. return vm.throw_completion<InternalError>(ErrorType::NotImplemented, TRY_OR_THROW_OOM(vm, executable_result.error().to_string()));
  374. auto bytecode_executable = executable_result.release_value();
  375. bytecode_executable->name = name;
  376. if (Bytecode::g_dump_bytecode)
  377. bytecode_executable->dump();
  378. return bytecode_executable;
  379. }
  380. Realm& Interpreter::realm()
  381. {
  382. return *m_vm.current_realm();
  383. }
  384. void Interpreter::push_call_frame(Variant<NonnullOwnPtr<CallFrame>, CallFrame*> frame, size_t register_count)
  385. {
  386. m_call_frames.append(move(frame));
  387. this->call_frame().registers.resize(register_count);
  388. m_current_call_frame = this->call_frame().registers;
  389. reg(Register::return_value()) = {};
  390. }
  391. Variant<NonnullOwnPtr<CallFrame>, CallFrame*> Interpreter::pop_call_frame()
  392. {
  393. auto frame = m_call_frames.take_last();
  394. m_current_call_frame = m_call_frames.is_empty() ? Span<Value> {} : this->call_frame().registers;
  395. return frame;
  396. }
  397. }
  398. namespace JS::Bytecode {
  399. DeprecatedString Instruction::to_deprecated_string(Bytecode::Executable const& executable) const
  400. {
  401. #define __BYTECODE_OP(op) \
  402. case Instruction::Type::op: \
  403. return static_cast<Bytecode::Op::op const&>(*this).to_deprecated_string_impl(executable);
  404. switch (type()) {
  405. ENUMERATE_BYTECODE_OPS(__BYTECODE_OP)
  406. default:
  407. VERIFY_NOT_REACHED();
  408. }
  409. #undef __BYTECODE_OP
  410. }
  411. }
  412. namespace JS::Bytecode::Op {
  413. ThrowCompletionOr<void> Load::execute_impl(Bytecode::Interpreter&) const
  414. {
  415. // Handled in the interpreter loop.
  416. __builtin_unreachable();
  417. }
  418. ThrowCompletionOr<void> LoadImmediate::execute_impl(Bytecode::Interpreter&) const
  419. {
  420. // Handled in the interpreter loop.
  421. __builtin_unreachable();
  422. }
  423. ThrowCompletionOr<void> Store::execute_impl(Bytecode::Interpreter&) const
  424. {
  425. // Handled in the interpreter loop.
  426. __builtin_unreachable();
  427. }
  428. static ThrowCompletionOr<Value> abstract_inequals(VM& vm, Value src1, Value src2)
  429. {
  430. return Value(!TRY(is_loosely_equal(vm, src1, src2)));
  431. }
  432. static ThrowCompletionOr<Value> abstract_equals(VM& vm, Value src1, Value src2)
  433. {
  434. return Value(TRY(is_loosely_equal(vm, src1, src2)));
  435. }
  436. static ThrowCompletionOr<Value> typed_inequals(VM&, Value src1, Value src2)
  437. {
  438. return Value(!is_strictly_equal(src1, src2));
  439. }
  440. static ThrowCompletionOr<Value> typed_equals(VM&, Value src1, Value src2)
  441. {
  442. return Value(is_strictly_equal(src1, src2));
  443. }
  444. #define JS_DEFINE_COMMON_BINARY_OP(OpTitleCase, op_snake_case) \
  445. ThrowCompletionOr<void> OpTitleCase::execute_impl(Bytecode::Interpreter& interpreter) const \
  446. { \
  447. auto& vm = interpreter.vm(); \
  448. auto lhs = interpreter.reg(m_lhs_reg); \
  449. auto rhs = interpreter.accumulator(); \
  450. interpreter.accumulator() = TRY(op_snake_case(vm, lhs, rhs)); \
  451. return {}; \
  452. } \
  453. DeprecatedString OpTitleCase::to_deprecated_string_impl(Bytecode::Executable const&) const \
  454. { \
  455. return DeprecatedString::formatted(#OpTitleCase " {}", m_lhs_reg); \
  456. }
  457. JS_ENUMERATE_COMMON_BINARY_OPS(JS_DEFINE_COMMON_BINARY_OP)
  458. static ThrowCompletionOr<Value> not_(VM&, Value value)
  459. {
  460. return Value(!value.to_boolean());
  461. }
  462. static ThrowCompletionOr<Value> typeof_(VM& vm, Value value)
  463. {
  464. return PrimitiveString::create(vm, value.typeof());
  465. }
  466. #define JS_DEFINE_COMMON_UNARY_OP(OpTitleCase, op_snake_case) \
  467. ThrowCompletionOr<void> OpTitleCase::execute_impl(Bytecode::Interpreter& interpreter) const \
  468. { \
  469. auto& vm = interpreter.vm(); \
  470. interpreter.accumulator() = TRY(op_snake_case(vm, interpreter.accumulator())); \
  471. return {}; \
  472. } \
  473. DeprecatedString OpTitleCase::to_deprecated_string_impl(Bytecode::Executable const&) const \
  474. { \
  475. return #OpTitleCase; \
  476. }
  477. JS_ENUMERATE_COMMON_UNARY_OPS(JS_DEFINE_COMMON_UNARY_OP)
  478. ThrowCompletionOr<void> NewBigInt::execute_impl(Bytecode::Interpreter& interpreter) const
  479. {
  480. auto& vm = interpreter.vm();
  481. interpreter.accumulator() = BigInt::create(vm, m_bigint);
  482. return {};
  483. }
  484. ThrowCompletionOr<void> NewArray::execute_impl(Bytecode::Interpreter& interpreter) const
  485. {
  486. auto array = MUST(Array::create(interpreter.realm(), 0));
  487. for (size_t i = 0; i < m_element_count; i++) {
  488. auto& value = interpreter.reg(Register(m_elements[0].index() + i));
  489. array->indexed_properties().put(i, value, default_attributes);
  490. }
  491. interpreter.accumulator() = array;
  492. return {};
  493. }
  494. ThrowCompletionOr<void> Append::execute_impl(Bytecode::Interpreter& interpreter) const
  495. {
  496. return append(interpreter.vm(), interpreter.reg(m_lhs), interpreter.accumulator(), m_is_spread);
  497. }
  498. ThrowCompletionOr<void> ImportCall::execute_impl(Bytecode::Interpreter& interpreter) const
  499. {
  500. auto& vm = interpreter.vm();
  501. auto specifier = interpreter.reg(m_specifier);
  502. auto options_value = interpreter.reg(m_options);
  503. interpreter.accumulator() = TRY(perform_import_call(vm, specifier, options_value));
  504. return {};
  505. }
  506. ThrowCompletionOr<void> IteratorToArray::execute_impl(Bytecode::Interpreter& interpreter) const
  507. {
  508. interpreter.accumulator() = TRY(iterator_to_array(interpreter.vm(), interpreter.accumulator()));
  509. return {};
  510. }
  511. ThrowCompletionOr<void> NewString::execute_impl(Bytecode::Interpreter& interpreter) const
  512. {
  513. interpreter.accumulator() = PrimitiveString::create(interpreter.vm(), interpreter.current_executable().get_string(m_string));
  514. return {};
  515. }
  516. ThrowCompletionOr<void> NewObject::execute_impl(Bytecode::Interpreter& interpreter) const
  517. {
  518. auto& vm = interpreter.vm();
  519. auto& realm = *vm.current_realm();
  520. interpreter.accumulator() = Object::create(realm, realm.intrinsics().object_prototype());
  521. return {};
  522. }
  523. ThrowCompletionOr<void> NewRegExp::execute_impl(Bytecode::Interpreter& interpreter) const
  524. {
  525. interpreter.accumulator() = new_regexp(
  526. interpreter.vm(),
  527. interpreter.current_executable().regex_table->get(m_regex_index),
  528. interpreter.current_executable().get_string(m_source_index),
  529. interpreter.current_executable().get_string(m_flags_index));
  530. return {};
  531. }
  532. #define JS_DEFINE_NEW_BUILTIN_ERROR_OP(ErrorName) \
  533. ThrowCompletionOr<void> New##ErrorName::execute_impl(Bytecode::Interpreter& interpreter) const \
  534. { \
  535. auto& vm = interpreter.vm(); \
  536. auto& realm = *vm.current_realm(); \
  537. interpreter.accumulator() = ErrorName::create(realm, interpreter.current_executable().get_string(m_error_string)); \
  538. return {}; \
  539. } \
  540. DeprecatedString New##ErrorName::to_deprecated_string_impl(Bytecode::Executable const& executable) const \
  541. { \
  542. return DeprecatedString::formatted("New" #ErrorName " {} (\"{}\")", m_error_string, executable.string_table->get(m_error_string)); \
  543. }
  544. JS_ENUMERATE_NEW_BUILTIN_ERROR_OPS(JS_DEFINE_NEW_BUILTIN_ERROR_OP)
  545. ThrowCompletionOr<void> CopyObjectExcludingProperties::execute_impl(Bytecode::Interpreter& interpreter) const
  546. {
  547. auto& vm = interpreter.vm();
  548. auto& realm = *vm.current_realm();
  549. auto from_object = interpreter.reg(m_from_object);
  550. auto to_object = Object::create(realm, realm.intrinsics().object_prototype());
  551. HashTable<PropertyKey> excluded_names;
  552. for (size_t i = 0; i < m_excluded_names_count; ++i) {
  553. excluded_names.set(TRY(interpreter.reg(m_excluded_names[i]).to_property_key(vm)));
  554. }
  555. TRY(to_object->copy_data_properties(vm, from_object, excluded_names));
  556. interpreter.accumulator() = to_object;
  557. return {};
  558. }
  559. ThrowCompletionOr<void> ConcatString::execute_impl(Bytecode::Interpreter& interpreter) const
  560. {
  561. auto& vm = interpreter.vm();
  562. auto string = TRY(interpreter.accumulator().to_primitive_string(vm));
  563. interpreter.reg(m_lhs) = PrimitiveString::create(vm, interpreter.reg(m_lhs).as_string(), string);
  564. return {};
  565. }
  566. ThrowCompletionOr<void> GetVariable::execute_impl(Bytecode::Interpreter& interpreter) const
  567. {
  568. interpreter.accumulator() = TRY(get_variable(interpreter, interpreter.current_executable().get_identifier(m_identifier), m_cache_index));
  569. return {};
  570. }
  571. ThrowCompletionOr<void> GetCalleeAndThisFromEnvironment::execute_impl(Bytecode::Interpreter& interpreter) const
  572. {
  573. auto callee_and_this = TRY(get_callee_and_this_from_environment(interpreter, interpreter.current_executable().get_identifier(m_identifier), m_cache_index));
  574. interpreter.reg(m_callee_reg) = callee_and_this.callee;
  575. interpreter.reg(m_this_reg) = callee_and_this.this_value;
  576. return {};
  577. }
  578. ThrowCompletionOr<void> GetGlobal::execute_impl(Bytecode::Interpreter& interpreter) const
  579. {
  580. interpreter.accumulator() = TRY(get_global(interpreter, interpreter.current_executable().get_identifier(m_identifier), m_cache_index));
  581. return {};
  582. }
  583. ThrowCompletionOr<void> GetLocal::execute_impl(Bytecode::Interpreter&) const
  584. {
  585. // Handled in the interpreter loop.
  586. __builtin_unreachable();
  587. }
  588. ThrowCompletionOr<void> DeleteVariable::execute_impl(Bytecode::Interpreter& interpreter) const
  589. {
  590. auto& vm = interpreter.vm();
  591. auto const& string = interpreter.current_executable().get_identifier(m_identifier);
  592. auto reference = TRY(vm.resolve_binding(string));
  593. interpreter.accumulator() = Value(TRY(reference.delete_(vm)));
  594. return {};
  595. }
  596. ThrowCompletionOr<void> CreateLexicalEnvironment::execute_impl(Bytecode::Interpreter& interpreter) const
  597. {
  598. auto make_and_swap_envs = [&](auto& old_environment) {
  599. GCPtr<Environment> environment = new_declarative_environment(*old_environment).ptr();
  600. swap(old_environment, environment);
  601. return environment;
  602. };
  603. interpreter.saved_lexical_environment_stack().append(make_and_swap_envs(interpreter.vm().running_execution_context().lexical_environment));
  604. return {};
  605. }
  606. ThrowCompletionOr<void> EnterObjectEnvironment::execute_impl(Bytecode::Interpreter& interpreter) const
  607. {
  608. auto& vm = interpreter.vm();
  609. auto& old_environment = vm.running_execution_context().lexical_environment;
  610. interpreter.saved_lexical_environment_stack().append(old_environment);
  611. auto object = TRY(interpreter.accumulator().to_object(vm));
  612. vm.running_execution_context().lexical_environment = new_object_environment(object, true, old_environment);
  613. return {};
  614. }
  615. ThrowCompletionOr<void> CreateVariable::execute_impl(Bytecode::Interpreter& interpreter) const
  616. {
  617. auto const& name = interpreter.current_executable().get_identifier(m_identifier);
  618. return create_variable(interpreter.vm(), name, m_mode, m_is_global, m_is_immutable, m_is_strict);
  619. }
  620. ThrowCompletionOr<void> SetVariable::execute_impl(Bytecode::Interpreter& interpreter) const
  621. {
  622. auto& vm = interpreter.vm();
  623. auto const& name = interpreter.current_executable().get_identifier(m_identifier);
  624. TRY(set_variable(vm, name, interpreter.accumulator(), m_mode, m_initialization_mode));
  625. return {};
  626. }
  627. ThrowCompletionOr<void> SetLocal::execute_impl(Bytecode::Interpreter&) const
  628. {
  629. // Handled in the interpreter loop.
  630. __builtin_unreachable();
  631. }
  632. ThrowCompletionOr<void> GetById::execute_impl(Bytecode::Interpreter& interpreter) const
  633. {
  634. auto base_value = interpreter.accumulator();
  635. auto& cache = interpreter.current_executable().property_lookup_caches[m_cache_index];
  636. interpreter.accumulator() = TRY(get_by_id(interpreter.vm(), interpreter.current_executable().get_identifier(m_property), base_value, base_value, cache));
  637. return {};
  638. }
  639. ThrowCompletionOr<void> GetByIdWithThis::execute_impl(Bytecode::Interpreter& interpreter) const
  640. {
  641. auto base_value = interpreter.accumulator();
  642. auto this_value = interpreter.reg(m_this_value);
  643. auto& cache = interpreter.current_executable().property_lookup_caches[m_cache_index];
  644. interpreter.accumulator() = TRY(get_by_id(interpreter.vm(), interpreter.current_executable().get_identifier(m_property), base_value, this_value, cache));
  645. return {};
  646. }
  647. ThrowCompletionOr<void> GetPrivateById::execute_impl(Bytecode::Interpreter& interpreter) const
  648. {
  649. auto& vm = interpreter.vm();
  650. auto const& name = interpreter.current_executable().get_identifier(m_property);
  651. auto base_value = interpreter.accumulator();
  652. auto private_reference = make_private_reference(vm, base_value, name);
  653. interpreter.accumulator() = TRY(private_reference.get_value(vm));
  654. return {};
  655. }
  656. ThrowCompletionOr<void> HasPrivateId::execute_impl(Bytecode::Interpreter& interpreter) const
  657. {
  658. auto& vm = interpreter.vm();
  659. if (!interpreter.accumulator().is_object())
  660. return vm.throw_completion<TypeError>(ErrorType::InOperatorWithObject);
  661. auto private_environment = vm.running_execution_context().private_environment;
  662. VERIFY(private_environment);
  663. auto private_name = private_environment->resolve_private_identifier(interpreter.current_executable().get_identifier(m_property));
  664. interpreter.accumulator() = Value(interpreter.accumulator().as_object().private_element_find(private_name) != nullptr);
  665. return {};
  666. }
  667. ThrowCompletionOr<void> PutById::execute_impl(Bytecode::Interpreter& interpreter) const
  668. {
  669. auto& vm = interpreter.vm();
  670. // NOTE: Get the value from the accumulator before side effects have a chance to overwrite it.
  671. auto value = interpreter.accumulator();
  672. auto base = interpreter.reg(m_base);
  673. PropertyKey name = interpreter.current_executable().get_identifier(m_property);
  674. TRY(put_by_property_key(vm, base, base, value, name, m_kind));
  675. interpreter.accumulator() = value;
  676. return {};
  677. }
  678. ThrowCompletionOr<void> PutByIdWithThis::execute_impl(Bytecode::Interpreter& interpreter) const
  679. {
  680. auto& vm = interpreter.vm();
  681. // NOTE: Get the value from the accumulator before side effects have a chance to overwrite it.
  682. auto value = interpreter.accumulator();
  683. auto base = interpreter.reg(m_base);
  684. PropertyKey name = interpreter.current_executable().get_identifier(m_property);
  685. TRY(put_by_property_key(vm, base, interpreter.reg(m_this_value), value, name, m_kind));
  686. interpreter.accumulator() = value;
  687. return {};
  688. }
  689. ThrowCompletionOr<void> PutPrivateById::execute_impl(Bytecode::Interpreter& interpreter) const
  690. {
  691. auto& vm = interpreter.vm();
  692. // NOTE: Get the value from the accumulator before side effects have a chance to overwrite it.
  693. auto value = interpreter.accumulator();
  694. auto object = TRY(interpreter.reg(m_base).to_object(vm));
  695. auto name = interpreter.current_executable().get_identifier(m_property);
  696. auto private_reference = make_private_reference(vm, object, name);
  697. TRY(private_reference.put_value(vm, value));
  698. interpreter.accumulator() = value;
  699. return {};
  700. }
  701. ThrowCompletionOr<void> DeleteById::execute_impl(Bytecode::Interpreter& interpreter) const
  702. {
  703. auto base_value = interpreter.accumulator();
  704. interpreter.accumulator() = TRY(Bytecode::delete_by_id(interpreter, base_value, m_property));
  705. return {};
  706. }
  707. ThrowCompletionOr<void> DeleteByIdWithThis::execute_impl(Bytecode::Interpreter& interpreter) const
  708. {
  709. auto& vm = interpreter.vm();
  710. auto base_value = interpreter.accumulator();
  711. auto const& identifier = interpreter.current_executable().get_identifier(m_property);
  712. bool strict = vm.in_strict_mode();
  713. auto reference = Reference { base_value, identifier, interpreter.reg(m_this_value), strict };
  714. interpreter.accumulator() = Value(TRY(reference.delete_(vm)));
  715. return {};
  716. }
  717. ThrowCompletionOr<void> Jump::execute_impl(Bytecode::Interpreter&) const
  718. {
  719. // Handled in the interpreter loop.
  720. __builtin_unreachable();
  721. }
  722. ThrowCompletionOr<void> ResolveThisBinding::execute_impl(Bytecode::Interpreter& interpreter) const
  723. {
  724. auto& cached_this_value = interpreter.reg(Register::this_value());
  725. if (cached_this_value.is_empty()) {
  726. // OPTIMIZATION: Because the value of 'this' cannot be reassigned during a function execution, it's
  727. // resolved once and then saved for subsequent use.
  728. auto& vm = interpreter.vm();
  729. cached_this_value = TRY(vm.resolve_this_binding());
  730. }
  731. interpreter.accumulator() = cached_this_value;
  732. return {};
  733. }
  734. // https://tc39.es/ecma262/#sec-makesuperpropertyreference
  735. ThrowCompletionOr<void> ResolveSuperBase::execute_impl(Bytecode::Interpreter& interpreter) const
  736. {
  737. auto& vm = interpreter.vm();
  738. // 1. Let env be GetThisEnvironment().
  739. auto& env = verify_cast<FunctionEnvironment>(*get_this_environment(vm));
  740. // 2. Assert: env.HasSuperBinding() is true.
  741. VERIFY(env.has_super_binding());
  742. // 3. Let baseValue be ? env.GetSuperBase().
  743. interpreter.accumulator() = TRY(env.get_super_base());
  744. return {};
  745. }
  746. ThrowCompletionOr<void> GetNewTarget::execute_impl(Bytecode::Interpreter& interpreter) const
  747. {
  748. interpreter.accumulator() = interpreter.vm().get_new_target();
  749. return {};
  750. }
  751. ThrowCompletionOr<void> GetImportMeta::execute_impl(Bytecode::Interpreter& interpreter) const
  752. {
  753. interpreter.accumulator() = interpreter.vm().get_import_meta();
  754. return {};
  755. }
  756. ThrowCompletionOr<void> JumpConditional::execute_impl(Bytecode::Interpreter&) const
  757. {
  758. // Handled in the interpreter loop.
  759. __builtin_unreachable();
  760. }
  761. ThrowCompletionOr<void> JumpNullish::execute_impl(Bytecode::Interpreter&) const
  762. {
  763. // Handled in the interpreter loop.
  764. __builtin_unreachable();
  765. }
  766. ThrowCompletionOr<void> JumpUndefined::execute_impl(Bytecode::Interpreter&) const
  767. {
  768. // Handled in the interpreter loop.
  769. __builtin_unreachable();
  770. }
  771. ThrowCompletionOr<void> Call::execute_impl(Bytecode::Interpreter& interpreter) const
  772. {
  773. auto& vm = interpreter.vm();
  774. auto callee = interpreter.reg(m_callee);
  775. TRY(throw_if_needed_for_call(interpreter, callee, call_type(), expression_string()));
  776. MarkedVector<Value> argument_values(vm.heap());
  777. argument_values.ensure_capacity(m_argument_count);
  778. for (u32 i = 0; i < m_argument_count; ++i) {
  779. argument_values.unchecked_append(interpreter.reg(Register { m_first_argument.index() + i }));
  780. }
  781. interpreter.accumulator() = TRY(perform_call(interpreter, interpreter.reg(m_this_value), call_type(), callee, move(argument_values)));
  782. return {};
  783. }
  784. ThrowCompletionOr<void> CallWithArgumentArray::execute_impl(Bytecode::Interpreter& interpreter) const
  785. {
  786. auto callee = interpreter.reg(m_callee);
  787. TRY(throw_if_needed_for_call(interpreter, callee, call_type(), expression_string()));
  788. auto argument_values = argument_list_evaluation(interpreter.vm(), interpreter.accumulator());
  789. interpreter.accumulator() = TRY(perform_call(interpreter, interpreter.reg(m_this_value), call_type(), callee, move(argument_values)));
  790. return {};
  791. }
  792. // 13.3.7.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-super-keyword-runtime-semantics-evaluation
  793. ThrowCompletionOr<void> SuperCallWithArgumentArray::execute_impl(Bytecode::Interpreter& interpreter) const
  794. {
  795. interpreter.accumulator() = TRY(super_call_with_argument_array(interpreter.vm(), interpreter.accumulator(), m_is_synthetic));
  796. return {};
  797. }
  798. ThrowCompletionOr<void> NewFunction::execute_impl(Bytecode::Interpreter& interpreter) const
  799. {
  800. auto& vm = interpreter.vm();
  801. interpreter.accumulator() = new_function(vm, m_function_node, m_lhs_name, m_home_object);
  802. return {};
  803. }
  804. ThrowCompletionOr<void> Return::execute_impl(Bytecode::Interpreter& interpreter) const
  805. {
  806. interpreter.do_return(interpreter.accumulator().value_or(js_undefined()));
  807. return {};
  808. }
  809. ThrowCompletionOr<void> Increment::execute_impl(Bytecode::Interpreter& interpreter) const
  810. {
  811. auto& vm = interpreter.vm();
  812. auto old_value = TRY(interpreter.accumulator().to_numeric(vm));
  813. if (old_value.is_number())
  814. interpreter.accumulator() = Value(old_value.as_double() + 1);
  815. else
  816. interpreter.accumulator() = BigInt::create(vm, old_value.as_bigint().big_integer().plus(Crypto::SignedBigInteger { 1 }));
  817. return {};
  818. }
  819. ThrowCompletionOr<void> Decrement::execute_impl(Bytecode::Interpreter& interpreter) const
  820. {
  821. auto& vm = interpreter.vm();
  822. auto old_value = TRY(interpreter.accumulator().to_numeric(vm));
  823. if (old_value.is_number())
  824. interpreter.accumulator() = Value(old_value.as_double() - 1);
  825. else
  826. interpreter.accumulator() = BigInt::create(vm, old_value.as_bigint().big_integer().minus(Crypto::SignedBigInteger { 1 }));
  827. return {};
  828. }
  829. ThrowCompletionOr<void> Throw::execute_impl(Bytecode::Interpreter& interpreter) const
  830. {
  831. return throw_completion(interpreter.accumulator());
  832. }
  833. ThrowCompletionOr<void> ThrowIfNotObject::execute_impl(Bytecode::Interpreter& interpreter) const
  834. {
  835. auto& vm = interpreter.vm();
  836. if (!interpreter.accumulator().is_object())
  837. return vm.throw_completion<TypeError>(ErrorType::NotAnObject, interpreter.accumulator().to_string_without_side_effects());
  838. return {};
  839. }
  840. ThrowCompletionOr<void> ThrowIfNullish::execute_impl(Bytecode::Interpreter& interpreter) const
  841. {
  842. auto& vm = interpreter.vm();
  843. auto value = interpreter.accumulator();
  844. if (value.is_nullish())
  845. return vm.throw_completion<TypeError>(ErrorType::NotObjectCoercible, value.to_string_without_side_effects());
  846. return {};
  847. }
  848. ThrowCompletionOr<void> EnterUnwindContext::execute_impl(Bytecode::Interpreter&) const
  849. {
  850. // Handled in the interpreter loop.
  851. __builtin_unreachable();
  852. }
  853. ThrowCompletionOr<void> ScheduleJump::execute_impl(Bytecode::Interpreter&) const
  854. {
  855. // Handled in the interpreter loop.
  856. __builtin_unreachable();
  857. }
  858. ThrowCompletionOr<void> LeaveLexicalEnvironment::execute_impl(Bytecode::Interpreter& interpreter) const
  859. {
  860. interpreter.vm().running_execution_context().lexical_environment = interpreter.saved_lexical_environment_stack().take_last();
  861. return {};
  862. }
  863. ThrowCompletionOr<void> LeaveUnwindContext::execute_impl(Bytecode::Interpreter& interpreter) const
  864. {
  865. interpreter.leave_unwind_context();
  866. return {};
  867. }
  868. ThrowCompletionOr<void> ContinuePendingUnwind::execute_impl(Bytecode::Interpreter&) const
  869. {
  870. // Handled in the interpreter loop.
  871. __builtin_unreachable();
  872. }
  873. ThrowCompletionOr<void> Yield::execute_impl(Bytecode::Interpreter& interpreter) const
  874. {
  875. auto yielded_value = interpreter.accumulator().value_or(js_undefined());
  876. auto object = Object::create(interpreter.realm(), nullptr);
  877. object->define_direct_property("result", yielded_value, JS::default_attributes);
  878. if (m_continuation_label.has_value())
  879. // FIXME: If we get a pointer, which is not accurately representable as a double
  880. // will cause this to explode
  881. object->define_direct_property("continuation", Value(static_cast<double>(reinterpret_cast<u64>(&m_continuation_label->block()))), JS::default_attributes);
  882. else
  883. object->define_direct_property("continuation", Value(0), JS::default_attributes);
  884. object->define_direct_property("isAwait", Value(false), JS::default_attributes);
  885. interpreter.do_return(object);
  886. return {};
  887. }
  888. ThrowCompletionOr<void> Await::execute_impl(Bytecode::Interpreter& interpreter) const
  889. {
  890. auto yielded_value = interpreter.accumulator().value_or(js_undefined());
  891. auto object = Object::create(interpreter.realm(), nullptr);
  892. object->define_direct_property("result", yielded_value, JS::default_attributes);
  893. // FIXME: If we get a pointer, which is not accurately representable as a double
  894. // will cause this to explode
  895. object->define_direct_property("continuation", Value(static_cast<double>(reinterpret_cast<u64>(&m_continuation_label.block()))), JS::default_attributes);
  896. object->define_direct_property("isAwait", Value(true), JS::default_attributes);
  897. interpreter.do_return(object);
  898. return {};
  899. }
  900. ThrowCompletionOr<void> GetByValue::execute_impl(Bytecode::Interpreter& interpreter) const
  901. {
  902. interpreter.accumulator() = TRY(get_by_value(interpreter.vm(), interpreter.reg(m_base), interpreter.accumulator()));
  903. return {};
  904. }
  905. ThrowCompletionOr<void> GetByValueWithThis::execute_impl(Bytecode::Interpreter& interpreter) const
  906. {
  907. auto& vm = interpreter.vm();
  908. // NOTE: Get the property key from the accumulator before side effects have a chance to overwrite it.
  909. auto property_key_value = interpreter.accumulator();
  910. auto object = TRY(interpreter.reg(m_base).to_object(vm));
  911. auto property_key = TRY(property_key_value.to_property_key(vm));
  912. interpreter.accumulator() = TRY(object->internal_get(property_key, interpreter.reg(m_this_value)));
  913. return {};
  914. }
  915. ThrowCompletionOr<void> PutByValue::execute_impl(Bytecode::Interpreter& interpreter) const
  916. {
  917. auto& vm = interpreter.vm();
  918. auto value = interpreter.accumulator();
  919. TRY(put_by_value(vm, interpreter.reg(m_base), interpreter.reg(m_property), interpreter.accumulator(), m_kind));
  920. interpreter.accumulator() = value;
  921. return {};
  922. }
  923. ThrowCompletionOr<void> PutByValueWithThis::execute_impl(Bytecode::Interpreter& interpreter) const
  924. {
  925. auto& vm = interpreter.vm();
  926. // NOTE: Get the value from the accumulator before side effects have a chance to overwrite it.
  927. auto value = interpreter.accumulator();
  928. auto base = interpreter.reg(m_base);
  929. auto property_key = m_kind != PropertyKind::Spread ? TRY(interpreter.reg(m_property).to_property_key(vm)) : PropertyKey {};
  930. TRY(put_by_property_key(vm, base, interpreter.reg(m_this_value), value, property_key, m_kind));
  931. interpreter.accumulator() = value;
  932. return {};
  933. }
  934. ThrowCompletionOr<void> DeleteByValue::execute_impl(Bytecode::Interpreter& interpreter) const
  935. {
  936. auto base_value = interpreter.reg(m_base);
  937. auto property_key_value = interpreter.accumulator();
  938. interpreter.accumulator() = TRY(delete_by_value(interpreter, base_value, property_key_value));
  939. return {};
  940. }
  941. ThrowCompletionOr<void> DeleteByValueWithThis::execute_impl(Bytecode::Interpreter& interpreter) const
  942. {
  943. // NOTE: Get the property key from the accumulator before side effects have a chance to overwrite it.
  944. auto property_key_value = interpreter.accumulator();
  945. auto base_value = interpreter.reg(m_base);
  946. auto this_value = interpreter.reg(m_this_value);
  947. interpreter.accumulator() = TRY(delete_by_value_with_this(interpreter, base_value, property_key_value, this_value));
  948. return {};
  949. }
  950. ThrowCompletionOr<void> GetIterator::execute_impl(Bytecode::Interpreter& interpreter) const
  951. {
  952. auto& vm = interpreter.vm();
  953. auto iterator = TRY(get_iterator(vm, interpreter.accumulator(), m_hint));
  954. interpreter.accumulator() = iterator_to_object(vm, iterator);
  955. return {};
  956. }
  957. ThrowCompletionOr<void> GetMethod::execute_impl(Bytecode::Interpreter& interpreter) const
  958. {
  959. auto& vm = interpreter.vm();
  960. auto identifier = interpreter.current_executable().get_identifier(m_property);
  961. auto method = TRY(interpreter.accumulator().get_method(vm, identifier));
  962. interpreter.accumulator() = method ?: js_undefined();
  963. return {};
  964. }
  965. ThrowCompletionOr<void> GetObjectPropertyIterator::execute_impl(Bytecode::Interpreter& interpreter) const
  966. {
  967. interpreter.accumulator() = TRY(get_object_property_iterator(interpreter.vm(), interpreter.accumulator()));
  968. return {};
  969. }
  970. ThrowCompletionOr<void> IteratorClose::execute_impl(Bytecode::Interpreter& interpreter) const
  971. {
  972. auto& vm = interpreter.vm();
  973. auto iterator_object = TRY(interpreter.accumulator().to_object(vm));
  974. auto iterator = object_to_iterator(vm, iterator_object);
  975. // FIXME: Return the value of the resulting completion. (Note that m_completion_value can be empty!)
  976. TRY(iterator_close(vm, iterator, Completion { m_completion_type, m_completion_value, {} }));
  977. return {};
  978. }
  979. ThrowCompletionOr<void> AsyncIteratorClose::execute_impl(Bytecode::Interpreter& interpreter) const
  980. {
  981. auto& vm = interpreter.vm();
  982. auto iterator_object = TRY(interpreter.accumulator().to_object(vm));
  983. auto iterator = object_to_iterator(vm, iterator_object);
  984. // FIXME: Return the value of the resulting completion. (Note that m_completion_value can be empty!)
  985. TRY(async_iterator_close(vm, iterator, Completion { m_completion_type, m_completion_value, {} }));
  986. return {};
  987. }
  988. ThrowCompletionOr<void> IteratorNext::execute_impl(Bytecode::Interpreter& interpreter) const
  989. {
  990. auto& vm = interpreter.vm();
  991. auto iterator_object = TRY(interpreter.accumulator().to_object(vm));
  992. auto iterator = object_to_iterator(vm, iterator_object);
  993. interpreter.accumulator() = TRY(iterator_next(vm, iterator));
  994. return {};
  995. }
  996. ThrowCompletionOr<void> IteratorResultDone::execute_impl(Bytecode::Interpreter& interpreter) const
  997. {
  998. auto& vm = interpreter.vm();
  999. auto iterator_result = TRY(interpreter.accumulator().to_object(vm));
  1000. auto complete = TRY(iterator_complete(vm, iterator_result));
  1001. interpreter.accumulator() = Value(complete);
  1002. return {};
  1003. }
  1004. ThrowCompletionOr<void> IteratorResultValue::execute_impl(Bytecode::Interpreter& interpreter) const
  1005. {
  1006. auto& vm = interpreter.vm();
  1007. auto iterator_result = TRY(interpreter.accumulator().to_object(vm));
  1008. interpreter.accumulator() = TRY(iterator_value(vm, iterator_result));
  1009. return {};
  1010. }
  1011. ThrowCompletionOr<void> NewClass::execute_impl(Bytecode::Interpreter& interpreter) const
  1012. {
  1013. interpreter.accumulator() = TRY(new_class(interpreter.vm(), interpreter.accumulator(), m_class_expression, m_lhs_name));
  1014. return {};
  1015. }
  1016. // 13.5.3.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-typeof-operator-runtime-semantics-evaluation
  1017. ThrowCompletionOr<void> TypeofVariable::execute_impl(Bytecode::Interpreter& interpreter) const
  1018. {
  1019. auto& vm = interpreter.vm();
  1020. interpreter.accumulator() = TRY(typeof_variable(vm, interpreter.current_executable().get_identifier(m_identifier)));
  1021. return {};
  1022. }
  1023. ThrowCompletionOr<void> TypeofLocal::execute_impl(Bytecode::Interpreter& interpreter) const
  1024. {
  1025. auto& vm = interpreter.vm();
  1026. auto const& value = vm.running_execution_context().local_variables[m_index];
  1027. interpreter.accumulator() = PrimitiveString::create(vm, value.typeof());
  1028. return {};
  1029. }
  1030. ThrowCompletionOr<void> ToNumeric::execute_impl(Bytecode::Interpreter& interpreter) const
  1031. {
  1032. interpreter.accumulator() = TRY(interpreter.accumulator().to_numeric(interpreter.vm()));
  1033. return {};
  1034. }
  1035. ThrowCompletionOr<void> BlockDeclarationInstantiation::execute_impl(Bytecode::Interpreter& interpreter) const
  1036. {
  1037. auto& vm = interpreter.vm();
  1038. auto old_environment = vm.running_execution_context().lexical_environment;
  1039. interpreter.saved_lexical_environment_stack().append(old_environment);
  1040. vm.running_execution_context().lexical_environment = new_declarative_environment(*old_environment);
  1041. m_scope_node.block_declaration_instantiation(vm, vm.running_execution_context().lexical_environment);
  1042. return {};
  1043. }
  1044. DeprecatedString Load::to_deprecated_string_impl(Bytecode::Executable const&) const
  1045. {
  1046. return DeprecatedString::formatted("Load {}", m_src);
  1047. }
  1048. DeprecatedString LoadImmediate::to_deprecated_string_impl(Bytecode::Executable const&) const
  1049. {
  1050. return DeprecatedString::formatted("LoadImmediate {}", m_value);
  1051. }
  1052. DeprecatedString Store::to_deprecated_string_impl(Bytecode::Executable const&) const
  1053. {
  1054. return DeprecatedString::formatted("Store {}", m_dst);
  1055. }
  1056. DeprecatedString NewBigInt::to_deprecated_string_impl(Bytecode::Executable const&) const
  1057. {
  1058. return DeprecatedString::formatted("NewBigInt \"{}\"", m_bigint.to_base_deprecated(10));
  1059. }
  1060. DeprecatedString NewArray::to_deprecated_string_impl(Bytecode::Executable const&) const
  1061. {
  1062. StringBuilder builder;
  1063. builder.append("NewArray"sv);
  1064. if (m_element_count != 0) {
  1065. builder.appendff(" [{}-{}]", m_elements[0], m_elements[1]);
  1066. }
  1067. return builder.to_deprecated_string();
  1068. }
  1069. DeprecatedString Append::to_deprecated_string_impl(Bytecode::Executable const&) const
  1070. {
  1071. if (m_is_spread)
  1072. return DeprecatedString::formatted("Append lhs: **{}", m_lhs);
  1073. return DeprecatedString::formatted("Append lhs: {}", m_lhs);
  1074. }
  1075. DeprecatedString IteratorToArray::to_deprecated_string_impl(Bytecode::Executable const&) const
  1076. {
  1077. return "IteratorToArray";
  1078. }
  1079. DeprecatedString NewString::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1080. {
  1081. return DeprecatedString::formatted("NewString {} (\"{}\")", m_string, executable.string_table->get(m_string));
  1082. }
  1083. DeprecatedString NewObject::to_deprecated_string_impl(Bytecode::Executable const&) const
  1084. {
  1085. return "NewObject";
  1086. }
  1087. DeprecatedString NewRegExp::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1088. {
  1089. return DeprecatedString::formatted("NewRegExp source:{} (\"{}\") flags:{} (\"{}\")", m_source_index, executable.get_string(m_source_index), m_flags_index, executable.get_string(m_flags_index));
  1090. }
  1091. DeprecatedString CopyObjectExcludingProperties::to_deprecated_string_impl(Bytecode::Executable const&) const
  1092. {
  1093. StringBuilder builder;
  1094. builder.appendff("CopyObjectExcludingProperties from:{}", m_from_object);
  1095. if (m_excluded_names_count != 0) {
  1096. builder.append(" excluding:["sv);
  1097. builder.join(", "sv, ReadonlySpan<Register>(m_excluded_names, m_excluded_names_count));
  1098. builder.append(']');
  1099. }
  1100. return builder.to_deprecated_string();
  1101. }
  1102. DeprecatedString ConcatString::to_deprecated_string_impl(Bytecode::Executable const&) const
  1103. {
  1104. return DeprecatedString::formatted("ConcatString {}", m_lhs);
  1105. }
  1106. DeprecatedString GetCalleeAndThisFromEnvironment::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1107. {
  1108. return DeprecatedString::formatted("GetCalleeAndThisFromEnvironment {} -> callee: {}, this:{} ", executable.identifier_table->get(m_identifier), m_callee_reg, m_this_reg);
  1109. }
  1110. DeprecatedString GetVariable::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1111. {
  1112. return DeprecatedString::formatted("GetVariable {} ({})", m_identifier, executable.identifier_table->get(m_identifier));
  1113. }
  1114. DeprecatedString GetGlobal::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1115. {
  1116. return DeprecatedString::formatted("GetGlobal {} ({})", m_identifier, executable.identifier_table->get(m_identifier));
  1117. }
  1118. DeprecatedString GetLocal::to_deprecated_string_impl(Bytecode::Executable const&) const
  1119. {
  1120. return DeprecatedString::formatted("GetLocal {}", m_index);
  1121. }
  1122. DeprecatedString DeleteVariable::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1123. {
  1124. return DeprecatedString::formatted("DeleteVariable {} ({})", m_identifier, executable.identifier_table->get(m_identifier));
  1125. }
  1126. DeprecatedString CreateLexicalEnvironment::to_deprecated_string_impl(Bytecode::Executable const&) const
  1127. {
  1128. return "CreateLexicalEnvironment"sv;
  1129. }
  1130. DeprecatedString CreateVariable::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1131. {
  1132. auto mode_string = m_mode == EnvironmentMode::Lexical ? "Lexical" : "Variable";
  1133. return DeprecatedString::formatted("CreateVariable env:{} immutable:{} global:{} {} ({})", mode_string, m_is_immutable, m_is_global, m_identifier, executable.identifier_table->get(m_identifier));
  1134. }
  1135. DeprecatedString EnterObjectEnvironment::to_deprecated_string_impl(Executable const&) const
  1136. {
  1137. return DeprecatedString::formatted("EnterObjectEnvironment");
  1138. }
  1139. DeprecatedString SetVariable::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1140. {
  1141. auto initialization_mode_name = m_initialization_mode == InitializationMode::Initialize ? "Initialize" : "Set";
  1142. auto mode_string = m_mode == EnvironmentMode::Lexical ? "Lexical" : "Variable";
  1143. return DeprecatedString::formatted("SetVariable env:{} init:{} {} ({})", mode_string, initialization_mode_name, m_identifier, executable.identifier_table->get(m_identifier));
  1144. }
  1145. DeprecatedString SetLocal::to_deprecated_string_impl(Bytecode::Executable const&) const
  1146. {
  1147. return DeprecatedString::formatted("SetLocal {}", m_index);
  1148. }
  1149. static StringView property_kind_to_string(PropertyKind kind)
  1150. {
  1151. switch (kind) {
  1152. case PropertyKind::Getter:
  1153. return "getter"sv;
  1154. case PropertyKind::Setter:
  1155. return "setter"sv;
  1156. case PropertyKind::KeyValue:
  1157. return "key-value"sv;
  1158. case PropertyKind::DirectKeyValue:
  1159. return "direct-key-value"sv;
  1160. case PropertyKind::Spread:
  1161. return "spread"sv;
  1162. case PropertyKind::ProtoSetter:
  1163. return "proto-setter"sv;
  1164. }
  1165. VERIFY_NOT_REACHED();
  1166. }
  1167. DeprecatedString PutById::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1168. {
  1169. auto kind = property_kind_to_string(m_kind);
  1170. return DeprecatedString::formatted("PutById kind:{} base:{}, property:{} ({})", kind, m_base, m_property, executable.identifier_table->get(m_property));
  1171. }
  1172. DeprecatedString PutByIdWithThis::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1173. {
  1174. auto kind = property_kind_to_string(m_kind);
  1175. return DeprecatedString::formatted("PutByIdWithThis kind:{} base:{}, property:{} ({}) this_value:{}", kind, m_base, m_property, executable.identifier_table->get(m_property), m_this_value);
  1176. }
  1177. DeprecatedString PutPrivateById::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1178. {
  1179. auto kind = property_kind_to_string(m_kind);
  1180. return DeprecatedString::formatted("PutPrivateById kind:{} base:{}, property:{} ({})", kind, m_base, m_property, executable.identifier_table->get(m_property));
  1181. }
  1182. DeprecatedString GetById::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1183. {
  1184. return DeprecatedString::formatted("GetById {} ({})", m_property, executable.identifier_table->get(m_property));
  1185. }
  1186. DeprecatedString GetByIdWithThis::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1187. {
  1188. return DeprecatedString::formatted("GetByIdWithThis {} ({}) this_value:{}", m_property, executable.identifier_table->get(m_property), m_this_value);
  1189. }
  1190. DeprecatedString GetPrivateById::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1191. {
  1192. return DeprecatedString::formatted("GetPrivateById {} ({})", m_property, executable.identifier_table->get(m_property));
  1193. }
  1194. DeprecatedString HasPrivateId::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1195. {
  1196. return DeprecatedString::formatted("HasPrivateId {} ({})", m_property, executable.identifier_table->get(m_property));
  1197. }
  1198. DeprecatedString DeleteById::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1199. {
  1200. return DeprecatedString::formatted("DeleteById {} ({})", m_property, executable.identifier_table->get(m_property));
  1201. }
  1202. DeprecatedString DeleteByIdWithThis::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1203. {
  1204. return DeprecatedString::formatted("DeleteByIdWithThis {} ({}) this_value:{}", m_property, executable.identifier_table->get(m_property), m_this_value);
  1205. }
  1206. DeprecatedString Jump::to_deprecated_string_impl(Bytecode::Executable const&) const
  1207. {
  1208. if (m_true_target.has_value())
  1209. return DeprecatedString::formatted("Jump {}", *m_true_target);
  1210. return DeprecatedString::formatted("Jump <empty>");
  1211. }
  1212. DeprecatedString JumpConditional::to_deprecated_string_impl(Bytecode::Executable const&) const
  1213. {
  1214. auto true_string = m_true_target.has_value() ? DeprecatedString::formatted("{}", *m_true_target) : "<empty>";
  1215. auto false_string = m_false_target.has_value() ? DeprecatedString::formatted("{}", *m_false_target) : "<empty>";
  1216. return DeprecatedString::formatted("JumpConditional true:{} false:{}", true_string, false_string);
  1217. }
  1218. DeprecatedString JumpNullish::to_deprecated_string_impl(Bytecode::Executable const&) const
  1219. {
  1220. auto true_string = m_true_target.has_value() ? DeprecatedString::formatted("{}", *m_true_target) : "<empty>";
  1221. auto false_string = m_false_target.has_value() ? DeprecatedString::formatted("{}", *m_false_target) : "<empty>";
  1222. return DeprecatedString::formatted("JumpNullish null:{} nonnull:{}", true_string, false_string);
  1223. }
  1224. DeprecatedString JumpUndefined::to_deprecated_string_impl(Bytecode::Executable const&) const
  1225. {
  1226. auto true_string = m_true_target.has_value() ? DeprecatedString::formatted("{}", *m_true_target) : "<empty>";
  1227. auto false_string = m_false_target.has_value() ? DeprecatedString::formatted("{}", *m_false_target) : "<empty>";
  1228. return DeprecatedString::formatted("JumpUndefined undefined:{} not undefined:{}", true_string, false_string);
  1229. }
  1230. static StringView call_type_to_string(CallType type)
  1231. {
  1232. switch (type) {
  1233. case CallType::Call:
  1234. return ""sv;
  1235. case CallType::Construct:
  1236. return " (Construct)"sv;
  1237. case CallType::DirectEval:
  1238. return " (DirectEval)"sv;
  1239. }
  1240. VERIFY_NOT_REACHED();
  1241. }
  1242. DeprecatedString Call::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1243. {
  1244. auto type = call_type_to_string(m_type);
  1245. if (m_expression_string.has_value())
  1246. return DeprecatedString::formatted("Call{} callee:{}, this:{}, first_arg:{} ({})", type, m_callee, m_this_value, m_first_argument, executable.get_string(m_expression_string.value()));
  1247. return DeprecatedString::formatted("Call{} callee:{}, this:{}, first_arg:{}", type, m_callee, m_first_argument, m_this_value);
  1248. }
  1249. DeprecatedString CallWithArgumentArray::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1250. {
  1251. auto type = call_type_to_string(m_type);
  1252. if (m_expression_string.has_value())
  1253. return DeprecatedString::formatted("CallWithArgumentArray{} callee:{}, this:{}, arguments:[...acc] ({})", type, m_callee, m_this_value, executable.get_string(m_expression_string.value()));
  1254. return DeprecatedString::formatted("CallWithArgumentArray{} callee:{}, this:{}, arguments:[...acc]", type, m_callee, m_this_value);
  1255. }
  1256. DeprecatedString SuperCallWithArgumentArray::to_deprecated_string_impl(Bytecode::Executable const&) const
  1257. {
  1258. return "SuperCallWithArgumentArray arguments:[...acc]"sv;
  1259. }
  1260. DeprecatedString NewFunction::to_deprecated_string_impl(Bytecode::Executable const&) const
  1261. {
  1262. StringBuilder builder;
  1263. builder.append("NewFunction"sv);
  1264. if (m_function_node.has_name())
  1265. builder.appendff(" name:{}"sv, m_function_node.name());
  1266. if (m_lhs_name.has_value())
  1267. builder.appendff(" lhs_name:{}"sv, m_lhs_name.value());
  1268. if (m_home_object.has_value())
  1269. builder.appendff(" home_object:{}"sv, m_home_object.value());
  1270. return builder.to_deprecated_string();
  1271. }
  1272. DeprecatedString NewClass::to_deprecated_string_impl(Bytecode::Executable const&) const
  1273. {
  1274. StringBuilder builder;
  1275. auto name = m_class_expression.name();
  1276. builder.appendff("NewClass '{}'"sv, name.is_null() ? ""sv : name);
  1277. if (m_lhs_name.has_value())
  1278. builder.appendff(" lhs_name:{}"sv, m_lhs_name.value());
  1279. return builder.to_deprecated_string();
  1280. }
  1281. DeprecatedString Return::to_deprecated_string_impl(Bytecode::Executable const&) const
  1282. {
  1283. return "Return";
  1284. }
  1285. DeprecatedString Increment::to_deprecated_string_impl(Bytecode::Executable const&) const
  1286. {
  1287. return "Increment";
  1288. }
  1289. DeprecatedString Decrement::to_deprecated_string_impl(Bytecode::Executable const&) const
  1290. {
  1291. return "Decrement";
  1292. }
  1293. DeprecatedString Throw::to_deprecated_string_impl(Bytecode::Executable const&) const
  1294. {
  1295. return "Throw";
  1296. }
  1297. DeprecatedString ThrowIfNotObject::to_deprecated_string_impl(Bytecode::Executable const&) const
  1298. {
  1299. return "ThrowIfNotObject";
  1300. }
  1301. DeprecatedString ThrowIfNullish::to_deprecated_string_impl(Bytecode::Executable const&) const
  1302. {
  1303. return "ThrowIfNullish";
  1304. }
  1305. DeprecatedString EnterUnwindContext::to_deprecated_string_impl(Bytecode::Executable const&) const
  1306. {
  1307. auto handler_string = m_handler_target.has_value() ? DeprecatedString::formatted("{}", *m_handler_target) : "<empty>";
  1308. auto finalizer_string = m_finalizer_target.has_value() ? DeprecatedString::formatted("{}", *m_finalizer_target) : "<empty>";
  1309. return DeprecatedString::formatted("EnterUnwindContext handler:{} finalizer:{} entry:{}", handler_string, finalizer_string, m_entry_point);
  1310. }
  1311. DeprecatedString ScheduleJump::to_deprecated_string_impl(Bytecode::Executable const&) const
  1312. {
  1313. return DeprecatedString::formatted("ScheduleJump {}", m_target);
  1314. }
  1315. DeprecatedString LeaveLexicalEnvironment::to_deprecated_string_impl(Bytecode::Executable const&) const
  1316. {
  1317. return "LeaveLexicalEnvironment"sv;
  1318. }
  1319. DeprecatedString LeaveUnwindContext::to_deprecated_string_impl(Bytecode::Executable const&) const
  1320. {
  1321. return "LeaveUnwindContext";
  1322. }
  1323. DeprecatedString ContinuePendingUnwind::to_deprecated_string_impl(Bytecode::Executable const&) const
  1324. {
  1325. return DeprecatedString::formatted("ContinuePendingUnwind resume:{}", m_resume_target);
  1326. }
  1327. DeprecatedString Yield::to_deprecated_string_impl(Bytecode::Executable const&) const
  1328. {
  1329. if (m_continuation_label.has_value())
  1330. return DeprecatedString::formatted("Yield continuation:@{}", m_continuation_label->block().name());
  1331. return DeprecatedString::formatted("Yield return");
  1332. }
  1333. DeprecatedString Await::to_deprecated_string_impl(Bytecode::Executable const&) const
  1334. {
  1335. return DeprecatedString::formatted("Await continuation:@{}", m_continuation_label.block().name());
  1336. }
  1337. DeprecatedString GetByValue::to_deprecated_string_impl(Bytecode::Executable const&) const
  1338. {
  1339. return DeprecatedString::formatted("GetByValue base:{}", m_base);
  1340. }
  1341. DeprecatedString GetByValueWithThis::to_deprecated_string_impl(Bytecode::Executable const&) const
  1342. {
  1343. return DeprecatedString::formatted("GetByValueWithThis base:{} this_value:{}", m_base, m_this_value);
  1344. }
  1345. DeprecatedString PutByValue::to_deprecated_string_impl(Bytecode::Executable const&) const
  1346. {
  1347. auto kind = property_kind_to_string(m_kind);
  1348. return DeprecatedString::formatted("PutByValue kind:{} base:{}, property:{}", kind, m_base, m_property);
  1349. }
  1350. DeprecatedString PutByValueWithThis::to_deprecated_string_impl(Bytecode::Executable const&) const
  1351. {
  1352. auto kind = property_kind_to_string(m_kind);
  1353. return DeprecatedString::formatted("PutByValueWithThis kind:{} base:{}, property:{} this_value:{}", kind, m_base, m_property, m_this_value);
  1354. }
  1355. DeprecatedString DeleteByValue::to_deprecated_string_impl(Bytecode::Executable const&) const
  1356. {
  1357. return DeprecatedString::formatted("DeleteByValue base:{}", m_base);
  1358. }
  1359. DeprecatedString DeleteByValueWithThis::to_deprecated_string_impl(Bytecode::Executable const&) const
  1360. {
  1361. return DeprecatedString::formatted("DeleteByValueWithThis base:{} this_value:{}", m_base, m_this_value);
  1362. }
  1363. DeprecatedString GetIterator::to_deprecated_string_impl(Executable const&) const
  1364. {
  1365. auto hint = m_hint == IteratorHint::Sync ? "sync" : "async";
  1366. return DeprecatedString::formatted("GetIterator hint:{}", hint);
  1367. }
  1368. DeprecatedString GetMethod::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1369. {
  1370. return DeprecatedString::formatted("GetMethod {} ({})", m_property, executable.identifier_table->get(m_property));
  1371. }
  1372. DeprecatedString GetObjectPropertyIterator::to_deprecated_string_impl(Bytecode::Executable const&) const
  1373. {
  1374. return "GetObjectPropertyIterator";
  1375. }
  1376. DeprecatedString IteratorClose::to_deprecated_string_impl(Bytecode::Executable const&) const
  1377. {
  1378. if (!m_completion_value.has_value())
  1379. return DeprecatedString::formatted("IteratorClose completion_type={} completion_value=<empty>", to_underlying(m_completion_type));
  1380. auto completion_value_string = m_completion_value->to_string_without_side_effects();
  1381. return DeprecatedString::formatted("IteratorClose completion_type={} completion_value={}", to_underlying(m_completion_type), completion_value_string);
  1382. }
  1383. DeprecatedString AsyncIteratorClose::to_deprecated_string_impl(Bytecode::Executable const&) const
  1384. {
  1385. if (!m_completion_value.has_value())
  1386. return DeprecatedString::formatted("AsyncIteratorClose completion_type={} completion_value=<empty>", to_underlying(m_completion_type));
  1387. auto completion_value_string = m_completion_value->to_string_without_side_effects();
  1388. return DeprecatedString::formatted("AsyncIteratorClose completion_type={} completion_value={}", to_underlying(m_completion_type), completion_value_string);
  1389. }
  1390. DeprecatedString IteratorNext::to_deprecated_string_impl(Executable const&) const
  1391. {
  1392. return "IteratorNext";
  1393. }
  1394. DeprecatedString IteratorResultDone::to_deprecated_string_impl(Executable const&) const
  1395. {
  1396. return "IteratorResultDone";
  1397. }
  1398. DeprecatedString IteratorResultValue::to_deprecated_string_impl(Executable const&) const
  1399. {
  1400. return "IteratorResultValue";
  1401. }
  1402. DeprecatedString ResolveThisBinding::to_deprecated_string_impl(Bytecode::Executable const&) const
  1403. {
  1404. return "ResolveThisBinding"sv;
  1405. }
  1406. DeprecatedString ResolveSuperBase::to_deprecated_string_impl(Bytecode::Executable const&) const
  1407. {
  1408. return "ResolveSuperBase"sv;
  1409. }
  1410. DeprecatedString GetNewTarget::to_deprecated_string_impl(Bytecode::Executable const&) const
  1411. {
  1412. return "GetNewTarget"sv;
  1413. }
  1414. DeprecatedString GetImportMeta::to_deprecated_string_impl(Bytecode::Executable const&) const
  1415. {
  1416. return "GetImportMeta"sv;
  1417. }
  1418. DeprecatedString TypeofVariable::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1419. {
  1420. return DeprecatedString::formatted("TypeofVariable {} ({})", m_identifier, executable.identifier_table->get(m_identifier));
  1421. }
  1422. DeprecatedString TypeofLocal::to_deprecated_string_impl(Bytecode::Executable const&) const
  1423. {
  1424. return DeprecatedString::formatted("TypeofLocal {}", m_index);
  1425. }
  1426. DeprecatedString ToNumeric::to_deprecated_string_impl(Bytecode::Executable const&) const
  1427. {
  1428. return "ToNumeric"sv;
  1429. }
  1430. DeprecatedString BlockDeclarationInstantiation::to_deprecated_string_impl(Bytecode::Executable const&) const
  1431. {
  1432. return "BlockDeclarationInstantiation"sv;
  1433. }
  1434. DeprecatedString ImportCall::to_deprecated_string_impl(Bytecode::Executable const&) const
  1435. {
  1436. return DeprecatedString::formatted("ImportCall specifier:{} options:{}"sv, m_specifier, m_options);
  1437. }
  1438. }