Interpreter.cpp 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416
  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/TemporaryChange.h>
  8. #include <LibJS/AST.h>
  9. #include <LibJS/Bytecode/BasicBlock.h>
  10. #include <LibJS/Bytecode/Generator.h>
  11. #include <LibJS/Bytecode/Instruction.h>
  12. #include <LibJS/Bytecode/Interpreter.h>
  13. #include <LibJS/Bytecode/Op.h>
  14. #include <LibJS/Runtime/GlobalEnvironment.h>
  15. #include <LibJS/Runtime/GlobalObject.h>
  16. #include <LibJS/Runtime/Realm.h>
  17. namespace JS::Bytecode {
  18. bool g_dump_bytecode = false;
  19. Interpreter::Interpreter(VM& vm)
  20. : m_vm(vm)
  21. {
  22. }
  23. Interpreter::~Interpreter()
  24. {
  25. }
  26. void Interpreter::visit_edges(Cell::Visitor& visitor)
  27. {
  28. if (m_return_value.has_value())
  29. visitor.visit(*m_return_value);
  30. if (m_saved_exception.has_value())
  31. visitor.visit(*m_saved_exception);
  32. for (auto& frame : m_call_frames) {
  33. frame.visit([&](auto& value) { value->visit_edges(visitor); });
  34. }
  35. }
  36. // 16.1.6 ScriptEvaluation ( scriptRecord ), https://tc39.es/ecma262/#sec-runtime-semantics-scriptevaluation
  37. ThrowCompletionOr<Value> Interpreter::run(Script& script_record, JS::GCPtr<Environment> lexical_environment_override)
  38. {
  39. auto& vm = this->vm();
  40. // 1. Let globalEnv be scriptRecord.[[Realm]].[[GlobalEnv]].
  41. auto& global_environment = script_record.realm().global_environment();
  42. // 2. Let scriptContext be a new ECMAScript code execution context.
  43. ExecutionContext script_context(vm.heap());
  44. // 3. Set the Function of scriptContext to null.
  45. // NOTE: This was done during execution context construction.
  46. // 4. Set the Realm of scriptContext to scriptRecord.[[Realm]].
  47. script_context.realm = &script_record.realm();
  48. // 5. Set the ScriptOrModule of scriptContext to scriptRecord.
  49. script_context.script_or_module = NonnullGCPtr<Script>(script_record);
  50. // 6. Set the VariableEnvironment of scriptContext to globalEnv.
  51. script_context.variable_environment = &global_environment;
  52. // 7. Set the LexicalEnvironment of scriptContext to globalEnv.
  53. script_context.lexical_environment = &global_environment;
  54. // Non-standard: Override the lexical environment if requested.
  55. if (lexical_environment_override)
  56. script_context.lexical_environment = lexical_environment_override;
  57. // 8. Set the PrivateEnvironment of scriptContext to null.
  58. // NOTE: This isn't in the spec, but we require it.
  59. script_context.is_strict_mode = script_record.parse_node().is_strict_mode();
  60. // FIXME: 9. Suspend the currently running execution context.
  61. // 10. Push scriptContext onto the execution context stack; scriptContext is now the running execution context.
  62. TRY(vm.push_execution_context(script_context, {}));
  63. // 11. Let script be scriptRecord.[[ECMAScriptCode]].
  64. auto& script = script_record.parse_node();
  65. // 12. Let result be Completion(GlobalDeclarationInstantiation(script, globalEnv)).
  66. auto instantiation_result = script.global_declaration_instantiation(vm, global_environment);
  67. Completion result = instantiation_result.is_throw_completion() ? instantiation_result.throw_completion() : normal_completion({});
  68. // 13. If result.[[Type]] is normal, then
  69. if (result.type() == Completion::Type::Normal) {
  70. auto executable_result = JS::Bytecode::Generator::generate(script);
  71. if (executable_result.is_error()) {
  72. if (auto error_string = executable_result.error().to_string(); error_string.is_error())
  73. result = vm.template throw_completion<JS::InternalError>(vm.error_message(JS::VM::ErrorMessage::OutOfMemory));
  74. else if (error_string = String::formatted("TODO({})", error_string.value()); error_string.is_error())
  75. result = vm.template throw_completion<JS::InternalError>(vm.error_message(JS::VM::ErrorMessage::OutOfMemory));
  76. else
  77. result = JS::throw_completion(JS::InternalError::create(realm(), error_string.release_value()));
  78. } else {
  79. auto executable = executable_result.release_value();
  80. if (g_dump_bytecode)
  81. executable->dump();
  82. // a. Set result to the result of evaluating script.
  83. auto result_or_error = run_and_return_frame(script_record.realm(), *executable, nullptr);
  84. if (result_or_error.value.is_error())
  85. result = result_or_error.value.release_error();
  86. else
  87. result = result_or_error.frame->registers[0];
  88. }
  89. }
  90. // 14. If result.[[Type]] is normal and result.[[Value]] is empty, then
  91. if (result.type() == Completion::Type::Normal && !result.value().has_value()) {
  92. // a. Set result to NormalCompletion(undefined).
  93. result = normal_completion(js_undefined());
  94. }
  95. // FIXME: 15. Suspend scriptContext and remove it from the execution context stack.
  96. vm.pop_execution_context();
  97. // 16. Assert: The execution context stack is not empty.
  98. VERIFY(!vm.execution_context_stack().is_empty());
  99. // FIXME: 17. Resume the context that is now on the top of the execution context stack as the running execution context.
  100. // At this point we may have already run any queued promise jobs via on_call_stack_emptied,
  101. // in which case this is a no-op.
  102. // 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.
  103. // https://tc39.es/ecma262/#sec-jobs for jobs and https://tc39.es/ecma262/#_ref_3508 for ClearKeptObjects
  104. // finish_execution_generation is particularly an issue for LibWeb, as the HTML spec wants to run it specifically after performing a microtask checkpoint.
  105. // The promise and registry cleanup queues don't cause LibWeb an issue, as LibWeb overrides the hooks that push onto these queues.
  106. vm.run_queued_promise_jobs();
  107. vm.run_queued_finalization_registry_cleanup_jobs();
  108. vm.finish_execution_generation();
  109. // 18. Return ? result.
  110. if (result.is_abrupt()) {
  111. VERIFY(result.type() == Completion::Type::Throw);
  112. return result.release_error();
  113. }
  114. VERIFY(result.value().has_value());
  115. return *result.value();
  116. }
  117. ThrowCompletionOr<Value> Interpreter::run(SourceTextModule& module)
  118. {
  119. // FIXME: This is not a entry point as defined in the spec, but is convenient.
  120. // To avoid work we use link_and_eval_module however that can already be
  121. // dangerous if the vm loaded other modules.
  122. auto& vm = this->vm();
  123. TRY(vm.link_and_eval_module(Badge<Bytecode::Interpreter> {}, module));
  124. vm.run_queued_promise_jobs();
  125. vm.run_queued_finalization_registry_cleanup_jobs();
  126. return js_undefined();
  127. }
  128. Interpreter::ValueAndFrame Interpreter::run_and_return_frame(Realm& realm, Executable& executable, BasicBlock const* entry_point, CallFrame* in_frame)
  129. {
  130. dbgln_if(JS_BYTECODE_DEBUG, "Bytecode::Interpreter will run unit {:p}", &executable);
  131. TemporaryChange restore_executable { m_current_executable, &executable };
  132. TemporaryChange restore_saved_jump { m_scheduled_jump, static_cast<BasicBlock const*>(nullptr) };
  133. TemporaryChange restore_saved_exception { m_saved_exception, {} };
  134. bool pushed_execution_context = false;
  135. ExecutionContext execution_context(vm().heap());
  136. if (vm().execution_context_stack().is_empty() || !vm().running_execution_context().lexical_environment) {
  137. // The "normal" interpreter pushes an execution context without environment so in that case we also want to push one.
  138. execution_context.this_value = &realm.global_object();
  139. static DeprecatedFlyString global_execution_context_name = "(*BC* global execution context)";
  140. execution_context.function_name = global_execution_context_name;
  141. execution_context.lexical_environment = &realm.global_environment();
  142. execution_context.variable_environment = &realm.global_environment();
  143. execution_context.realm = realm;
  144. execution_context.is_strict_mode = executable.is_strict_mode;
  145. vm().push_execution_context(execution_context);
  146. pushed_execution_context = true;
  147. }
  148. TemporaryChange restore_current_block { m_current_block, entry_point ?: executable.basic_blocks.first() };
  149. if (in_frame)
  150. push_call_frame(in_frame, executable.number_of_registers);
  151. else
  152. push_call_frame(make<CallFrame>(), executable.number_of_registers);
  153. TemporaryChange restore_this_value { m_this_value, {} };
  154. for (;;) {
  155. Bytecode::InstructionStreamIterator pc(m_current_block->instruction_stream());
  156. TemporaryChange temp_change { m_pc, &pc };
  157. // FIXME: This is getting kinda spaghetti-y
  158. bool will_jump = false;
  159. bool will_return = false;
  160. bool will_yield = false;
  161. while (!pc.at_end()) {
  162. auto& instruction = *pc;
  163. auto ran_or_error = instruction.execute(*this);
  164. if (ran_or_error.is_error()) {
  165. auto exception_value = *ran_or_error.throw_completion().value();
  166. m_saved_exception = exception_value;
  167. if (unwind_contexts().is_empty())
  168. break;
  169. auto& unwind_context = unwind_contexts().last();
  170. if (unwind_context.executable != m_current_executable)
  171. break;
  172. if (unwind_context.handler && !unwind_context.handler_called) {
  173. vm().running_execution_context().lexical_environment = unwind_context.lexical_environment;
  174. m_current_block = unwind_context.handler;
  175. unwind_context.handler_called = true;
  176. accumulator() = exception_value;
  177. m_saved_exception = {};
  178. will_jump = true;
  179. break;
  180. }
  181. if (unwind_context.finalizer) {
  182. m_current_block = unwind_context.finalizer;
  183. // If an exception was thrown inside the corresponding `catch` block, we need to rethrow it
  184. // from the `finally` block. But if the exception is from the `try` block, and has already been
  185. // handled by `catch`, we swallow it.
  186. if (!unwind_context.handler_called)
  187. m_saved_exception = {};
  188. will_jump = true;
  189. break;
  190. }
  191. // 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.
  192. // If you run into this, you probably forgot to remove the current unwind_context somewhere.
  193. VERIFY_NOT_REACHED();
  194. }
  195. if (m_pending_jump.has_value()) {
  196. m_current_block = m_pending_jump.release_value();
  197. will_jump = true;
  198. break;
  199. }
  200. if (m_return_value.has_value()) {
  201. will_return = true;
  202. // Note: A `yield` statement will not go through a finally statement,
  203. // hence we need to set a flag to not do so,
  204. // but we generate a Yield Operation in the case of returns in
  205. // generators as well, so we need to check if it will actually
  206. // continue or is a `return` in disguise
  207. will_yield = (instruction.type() == Instruction::Type::Yield && static_cast<Op::Yield const&>(instruction).continuation().has_value()) || instruction.type() == Instruction::Type::Await;
  208. break;
  209. }
  210. ++pc;
  211. }
  212. if (will_jump)
  213. continue;
  214. if (!unwind_contexts().is_empty() && !will_yield) {
  215. auto& unwind_context = unwind_contexts().last();
  216. if (unwind_context.executable == m_current_executable && unwind_context.finalizer) {
  217. reg(Register::saved_return_value()) = m_return_value.release_value();
  218. m_current_block = unwind_context.finalizer;
  219. // the unwind_context will be pop'ed when entering the finally block
  220. continue;
  221. }
  222. }
  223. if (pc.at_end())
  224. break;
  225. if (m_saved_exception.has_value())
  226. break;
  227. if (will_return)
  228. break;
  229. }
  230. dbgln_if(JS_BYTECODE_DEBUG, "Bytecode::Interpreter did run unit {:p}", &executable);
  231. if constexpr (JS_BYTECODE_DEBUG) {
  232. for (size_t i = 0; i < registers().size(); ++i) {
  233. String value_string;
  234. if (registers()[i].is_empty())
  235. value_string = "(empty)"_string;
  236. else
  237. value_string = registers()[i].to_string_without_side_effects();
  238. dbgln("[{:3}] {}", i, value_string);
  239. }
  240. }
  241. auto saved_return_value = reg(Register::saved_return_value());
  242. auto frame = pop_call_frame();
  243. Value return_value = js_undefined();
  244. if (m_return_value.has_value()) {
  245. return_value = m_return_value.release_value();
  246. } else if (!saved_return_value.is_empty()) {
  247. return_value = saved_return_value;
  248. }
  249. // NOTE: The return value from a called function is put into $0 in the caller context.
  250. if (!m_call_frames.is_empty())
  251. call_frame().registers[0] = return_value;
  252. // At this point we may have already run any queued promise jobs via on_call_stack_emptied,
  253. // in which case this is a no-op.
  254. vm().run_queued_promise_jobs();
  255. if (pushed_execution_context) {
  256. VERIFY(&vm().running_execution_context() == &execution_context);
  257. vm().pop_execution_context();
  258. }
  259. vm().finish_execution_generation();
  260. if (m_saved_exception.has_value()) {
  261. Value thrown_value = m_saved_exception.value();
  262. m_saved_exception = {};
  263. if (auto* call_frame = frame.get_pointer<NonnullOwnPtr<CallFrame>>())
  264. return { throw_completion(thrown_value), move(*call_frame) };
  265. return { throw_completion(thrown_value), nullptr };
  266. }
  267. if (auto* call_frame = frame.get_pointer<NonnullOwnPtr<CallFrame>>())
  268. return { return_value, move(*call_frame) };
  269. return { return_value, nullptr };
  270. }
  271. void Interpreter::enter_unwind_context(Optional<Label> handler_target, Optional<Label> finalizer_target)
  272. {
  273. unwind_contexts().empend(
  274. m_current_executable,
  275. handler_target.has_value() ? &handler_target->block() : nullptr,
  276. finalizer_target.has_value() ? &finalizer_target->block() : nullptr,
  277. vm().running_execution_context().lexical_environment);
  278. }
  279. void Interpreter::leave_unwind_context()
  280. {
  281. unwind_contexts().take_last();
  282. }
  283. ThrowCompletionOr<void> Interpreter::continue_pending_unwind(Label const& resume_label)
  284. {
  285. if (m_saved_exception.has_value()) {
  286. return throw_completion(m_saved_exception.release_value());
  287. }
  288. if (!saved_return_value().is_empty()) {
  289. do_return(saved_return_value());
  290. return {};
  291. }
  292. if (m_scheduled_jump) {
  293. // FIXME: If we `break` or `continue` in the finally, we need to clear
  294. // this field
  295. jump(Label { *m_scheduled_jump });
  296. m_scheduled_jump = nullptr;
  297. } else {
  298. jump(resume_label);
  299. }
  300. return {};
  301. }
  302. size_t Interpreter::pc() const
  303. {
  304. return m_pc ? m_pc->offset() : 0;
  305. }
  306. DeprecatedString Interpreter::debug_position() const
  307. {
  308. return DeprecatedString::formatted("{}:{:2}:{:4x}", m_current_executable->name, m_current_block->name(), pc());
  309. }
  310. ThrowCompletionOr<NonnullOwnPtr<Bytecode::Executable>> compile(VM& vm, ASTNode const& node, FunctionKind kind, DeprecatedFlyString const& name)
  311. {
  312. auto executable_result = Bytecode::Generator::generate(node, kind);
  313. if (executable_result.is_error())
  314. return vm.throw_completion<InternalError>(ErrorType::NotImplemented, TRY_OR_THROW_OOM(vm, executable_result.error().to_string()));
  315. auto bytecode_executable = executable_result.release_value();
  316. bytecode_executable->name = name;
  317. if (Bytecode::g_dump_bytecode)
  318. bytecode_executable->dump();
  319. return bytecode_executable;
  320. }
  321. Realm& Interpreter::realm()
  322. {
  323. return *m_vm.current_realm();
  324. }
  325. void Interpreter::push_call_frame(Variant<NonnullOwnPtr<CallFrame>, CallFrame*> frame, size_t register_count)
  326. {
  327. m_call_frames.append(move(frame));
  328. this->call_frame().registers.resize(register_count);
  329. m_current_call_frame = this->call_frame().registers;
  330. }
  331. Variant<NonnullOwnPtr<CallFrame>, CallFrame*> Interpreter::pop_call_frame()
  332. {
  333. auto frame = m_call_frames.take_last();
  334. m_current_call_frame = m_call_frames.is_empty() ? Span<Value> {} : this->call_frame().registers;
  335. return frame;
  336. }
  337. }