Op.cpp 77 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854
  1. /*
  2. * Copyright (c) 2021-2023, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2021-2023, Linus Groh <linusg@serenityos.org>
  4. * Copyright (c) 2021, Gunnar Beutner <gbeutner@serenityos.org>
  5. *
  6. * SPDX-License-Identifier: BSD-2-Clause
  7. */
  8. #include <AK/HashTable.h>
  9. #include <LibJS/AST.h>
  10. #include <LibJS/Bytecode/Interpreter.h>
  11. #include <LibJS/Bytecode/Op.h>
  12. #include <LibJS/Runtime/AbstractOperations.h>
  13. #include <LibJS/Runtime/Array.h>
  14. #include <LibJS/Runtime/BigInt.h>
  15. #include <LibJS/Runtime/DeclarativeEnvironment.h>
  16. #include <LibJS/Runtime/ECMAScriptFunctionObject.h>
  17. #include <LibJS/Runtime/Environment.h>
  18. #include <LibJS/Runtime/FunctionEnvironment.h>
  19. #include <LibJS/Runtime/GlobalEnvironment.h>
  20. #include <LibJS/Runtime/GlobalObject.h>
  21. #include <LibJS/Runtime/Iterator.h>
  22. #include <LibJS/Runtime/IteratorOperations.h>
  23. #include <LibJS/Runtime/NativeFunction.h>
  24. #include <LibJS/Runtime/ObjectEnvironment.h>
  25. #include <LibJS/Runtime/Reference.h>
  26. #include <LibJS/Runtime/RegExpObject.h>
  27. #include <LibJS/Runtime/Value.h>
  28. namespace JS::Bytecode {
  29. DeprecatedString Instruction::to_deprecated_string(Bytecode::Executable const& executable) const
  30. {
  31. #define __BYTECODE_OP(op) \
  32. case Instruction::Type::op: \
  33. return static_cast<Bytecode::Op::op const&>(*this).to_deprecated_string_impl(executable);
  34. switch (type()) {
  35. ENUMERATE_BYTECODE_OPS(__BYTECODE_OP)
  36. default:
  37. VERIFY_NOT_REACHED();
  38. }
  39. #undef __BYTECODE_OP
  40. }
  41. }
  42. namespace JS::Bytecode::Op {
  43. static ThrowCompletionOr<void> put_by_property_key(VM& vm, Value base, Value this_value, Value value, PropertyKey name, PropertyKind kind)
  44. {
  45. auto object = TRY(base.to_object(vm));
  46. if (kind == PropertyKind::Getter || kind == PropertyKind::Setter) {
  47. // The generator should only pass us functions for getters and setters.
  48. VERIFY(value.is_function());
  49. }
  50. switch (kind) {
  51. case PropertyKind::Getter: {
  52. auto& function = value.as_function();
  53. if (function.name().is_empty() && is<ECMAScriptFunctionObject>(function))
  54. static_cast<ECMAScriptFunctionObject*>(&function)->set_name(DeprecatedString::formatted("get {}", name));
  55. object->define_direct_accessor(name, &function, nullptr, Attribute::Configurable | Attribute::Enumerable);
  56. break;
  57. }
  58. case PropertyKind::Setter: {
  59. auto& function = value.as_function();
  60. if (function.name().is_empty() && is<ECMAScriptFunctionObject>(function))
  61. static_cast<ECMAScriptFunctionObject*>(&function)->set_name(DeprecatedString::formatted("set {}", name));
  62. object->define_direct_accessor(name, nullptr, &function, Attribute::Configurable | Attribute::Enumerable);
  63. break;
  64. }
  65. case PropertyKind::KeyValue: {
  66. bool succeeded = TRY(object->internal_set(name, value, this_value));
  67. if (!succeeded && vm.in_strict_mode())
  68. return vm.throw_completion<TypeError>(ErrorType::ReferenceNullishSetProperty, name, TRY_OR_THROW_OOM(vm, base.to_string_without_side_effects()));
  69. break;
  70. }
  71. case PropertyKind::DirectKeyValue:
  72. object->define_direct_property(name, value, Attribute::Enumerable | Attribute::Writable | Attribute::Configurable);
  73. break;
  74. case PropertyKind::Spread:
  75. TRY(object->copy_data_properties(vm, value, {}));
  76. break;
  77. case PropertyKind::ProtoSetter:
  78. if (value.is_object() || value.is_null())
  79. MUST(object->internal_set_prototype_of(value.is_object() ? &value.as_object() : nullptr));
  80. break;
  81. }
  82. return {};
  83. }
  84. ThrowCompletionOr<void> Load::execute_impl(Bytecode::Interpreter& interpreter) const
  85. {
  86. interpreter.accumulator() = interpreter.reg(m_src);
  87. return {};
  88. }
  89. ThrowCompletionOr<void> LoadImmediate::execute_impl(Bytecode::Interpreter& interpreter) const
  90. {
  91. interpreter.accumulator() = m_value;
  92. return {};
  93. }
  94. ThrowCompletionOr<void> Store::execute_impl(Bytecode::Interpreter& interpreter) const
  95. {
  96. interpreter.reg(m_dst) = interpreter.accumulator();
  97. return {};
  98. }
  99. static ThrowCompletionOr<Value> abstract_inequals(VM& vm, Value src1, Value src2)
  100. {
  101. return Value(!TRY(is_loosely_equal(vm, src1, src2)));
  102. }
  103. static ThrowCompletionOr<Value> abstract_equals(VM& vm, Value src1, Value src2)
  104. {
  105. return Value(TRY(is_loosely_equal(vm, src1, src2)));
  106. }
  107. static ThrowCompletionOr<Value> typed_inequals(VM&, Value src1, Value src2)
  108. {
  109. return Value(!is_strictly_equal(src1, src2));
  110. }
  111. static ThrowCompletionOr<Value> typed_equals(VM&, Value src1, Value src2)
  112. {
  113. return Value(is_strictly_equal(src1, src2));
  114. }
  115. #define JS_DEFINE_COMMON_BINARY_OP(OpTitleCase, op_snake_case) \
  116. ThrowCompletionOr<void> OpTitleCase::execute_impl(Bytecode::Interpreter& interpreter) const \
  117. { \
  118. auto& vm = interpreter.vm(); \
  119. auto lhs = interpreter.reg(m_lhs_reg); \
  120. auto rhs = interpreter.accumulator(); \
  121. interpreter.accumulator() = TRY(op_snake_case(vm, lhs, rhs)); \
  122. return {}; \
  123. } \
  124. DeprecatedString OpTitleCase::to_deprecated_string_impl(Bytecode::Executable const&) const \
  125. { \
  126. return DeprecatedString::formatted(#OpTitleCase " {}", m_lhs_reg); \
  127. }
  128. JS_ENUMERATE_COMMON_BINARY_OPS(JS_DEFINE_COMMON_BINARY_OP)
  129. static ThrowCompletionOr<Value> not_(VM&, Value value)
  130. {
  131. return Value(!value.to_boolean());
  132. }
  133. static ThrowCompletionOr<Value> typeof_(VM& vm, Value value)
  134. {
  135. return MUST_OR_THROW_OOM(PrimitiveString::create(vm, value.typeof()));
  136. }
  137. #define JS_DEFINE_COMMON_UNARY_OP(OpTitleCase, op_snake_case) \
  138. ThrowCompletionOr<void> OpTitleCase::execute_impl(Bytecode::Interpreter& interpreter) const \
  139. { \
  140. auto& vm = interpreter.vm(); \
  141. interpreter.accumulator() = TRY(op_snake_case(vm, interpreter.accumulator())); \
  142. return {}; \
  143. } \
  144. DeprecatedString OpTitleCase::to_deprecated_string_impl(Bytecode::Executable const&) const \
  145. { \
  146. return #OpTitleCase; \
  147. }
  148. JS_ENUMERATE_COMMON_UNARY_OPS(JS_DEFINE_COMMON_UNARY_OP)
  149. ThrowCompletionOr<void> NewBigInt::execute_impl(Bytecode::Interpreter& interpreter) const
  150. {
  151. auto& vm = interpreter.vm();
  152. interpreter.accumulator() = BigInt::create(vm, m_bigint);
  153. return {};
  154. }
  155. ThrowCompletionOr<void> NewArray::execute_impl(Bytecode::Interpreter& interpreter) const
  156. {
  157. auto array = MUST(Array::create(interpreter.realm(), 0));
  158. for (size_t i = 0; i < m_element_count; i++) {
  159. auto& value = interpreter.reg(Register(m_elements[0].index() + i));
  160. array->indexed_properties().put(i, value, default_attributes);
  161. }
  162. interpreter.accumulator() = array;
  163. return {};
  164. }
  165. ThrowCompletionOr<void> Append::execute_impl(Bytecode::Interpreter& interpreter) const
  166. {
  167. // Note: This OpCode is used to construct array literals and argument arrays for calls,
  168. // containing at least one spread element,
  169. // Iterating over such a spread element to unpack it has to be visible by
  170. // the user courtesy of
  171. // (1) https://tc39.es/ecma262/#sec-runtime-semantics-arrayaccumulation
  172. // SpreadElement : ... AssignmentExpression
  173. // 1. Let spreadRef be ? Evaluation of AssignmentExpression.
  174. // 2. Let spreadObj be ? GetValue(spreadRef).
  175. // 3. Let iteratorRecord be ? GetIterator(spreadObj).
  176. // 4. Repeat,
  177. // a. Let next be ? IteratorStep(iteratorRecord).
  178. // b. If next is false, return nextIndex.
  179. // c. Let nextValue be ? IteratorValue(next).
  180. // d. Perform ! CreateDataPropertyOrThrow(array, ! ToString(𝔽(nextIndex)), nextValue).
  181. // e. Set nextIndex to nextIndex + 1.
  182. // (2) https://tc39.es/ecma262/#sec-runtime-semantics-argumentlistevaluation
  183. // ArgumentList : ... AssignmentExpression
  184. // 1. Let list be a new empty List.
  185. // 2. Let spreadRef be ? Evaluation of AssignmentExpression.
  186. // 3. Let spreadObj be ? GetValue(spreadRef).
  187. // 4. Let iteratorRecord be ? GetIterator(spreadObj).
  188. // 5. Repeat,
  189. // a. Let next be ? IteratorStep(iteratorRecord).
  190. // b. If next is false, return list.
  191. // c. Let nextArg be ? IteratorValue(next).
  192. // d. Append nextArg to list.
  193. // ArgumentList : ArgumentList , ... AssignmentExpression
  194. // 1. Let precedingArgs be ? ArgumentListEvaluation of ArgumentList.
  195. // 2. Let spreadRef be ? Evaluation of AssignmentExpression.
  196. // 3. Let iteratorRecord be ? GetIterator(? GetValue(spreadRef)).
  197. // 4. Repeat,
  198. // a. Let next be ? IteratorStep(iteratorRecord).
  199. // b. If next is false, return precedingArgs.
  200. // c. Let nextArg be ? IteratorValue(next).
  201. // d. Append nextArg to precedingArgs.
  202. auto& vm = interpreter.vm();
  203. // Note: We know from codegen, that lhs is a plain array with only indexed properties
  204. auto& lhs = interpreter.reg(m_lhs).as_array();
  205. auto lhs_size = lhs.indexed_properties().array_like_size();
  206. auto rhs = interpreter.accumulator();
  207. if (m_is_spread) {
  208. // ...rhs
  209. size_t i = lhs_size;
  210. TRY(get_iterator_values(vm, rhs, [&i, &lhs](Value iterator_value) -> Optional<Completion> {
  211. lhs.indexed_properties().put(i, iterator_value, default_attributes);
  212. ++i;
  213. return {};
  214. }));
  215. } else {
  216. lhs.indexed_properties().put(lhs_size, rhs, default_attributes);
  217. }
  218. return {};
  219. }
  220. ThrowCompletionOr<void> ImportCall::execute_impl(Bytecode::Interpreter& interpreter) const
  221. {
  222. auto& vm = interpreter.vm();
  223. auto specifier = interpreter.reg(m_specifier);
  224. auto options_value = interpreter.reg(m_options);
  225. interpreter.accumulator() = TRY(perform_import_call(vm, specifier, options_value));
  226. return {};
  227. }
  228. void ImportCall::replace_references_impl(Register from, Register to)
  229. {
  230. if (m_specifier == from)
  231. m_specifier = to;
  232. if (m_options == from)
  233. m_options = to;
  234. }
  235. // FIXME: Since the accumulator is a Value, we store an object there and have to convert back and forth between that an Iterator records. Not great.
  236. // Make sure to put this into the accumulator before the iterator object disappears from the stack to prevent the members from being GC'd.
  237. static Object* iterator_to_object(VM& vm, IteratorRecord iterator)
  238. {
  239. auto& realm = *vm.current_realm();
  240. auto object = Object::create(realm, nullptr);
  241. object->define_direct_property(vm.names.iterator, iterator.iterator, 0);
  242. object->define_direct_property(vm.names.next, iterator.next_method, 0);
  243. object->define_direct_property(vm.names.done, Value(iterator.done), 0);
  244. return object;
  245. }
  246. static IteratorRecord object_to_iterator(VM& vm, Object& object)
  247. {
  248. return IteratorRecord {
  249. .iterator = &MUST(object.get(vm.names.iterator)).as_object(),
  250. .next_method = MUST(object.get(vm.names.next)),
  251. .done = MUST(object.get(vm.names.done)).as_bool()
  252. };
  253. }
  254. ThrowCompletionOr<void> IteratorToArray::execute_impl(Bytecode::Interpreter& interpreter) const
  255. {
  256. auto& vm = interpreter.vm();
  257. auto iterator_object = TRY(interpreter.accumulator().to_object(vm));
  258. auto iterator = object_to_iterator(vm, iterator_object);
  259. auto array = MUST(Array::create(interpreter.realm(), 0));
  260. size_t index = 0;
  261. while (true) {
  262. auto iterator_result = TRY(iterator_next(vm, iterator));
  263. auto complete = TRY(iterator_complete(vm, iterator_result));
  264. if (complete) {
  265. interpreter.accumulator() = array;
  266. return {};
  267. }
  268. auto value = TRY(iterator_value(vm, iterator_result));
  269. MUST(array->create_data_property_or_throw(index, value));
  270. index++;
  271. }
  272. return {};
  273. }
  274. ThrowCompletionOr<void> NewString::execute_impl(Bytecode::Interpreter& interpreter) const
  275. {
  276. interpreter.accumulator() = PrimitiveString::create(interpreter.vm(), interpreter.current_executable().get_string(m_string));
  277. return {};
  278. }
  279. ThrowCompletionOr<void> NewObject::execute_impl(Bytecode::Interpreter& interpreter) const
  280. {
  281. auto& vm = interpreter.vm();
  282. auto& realm = *vm.current_realm();
  283. interpreter.accumulator() = Object::create(realm, realm.intrinsics().object_prototype());
  284. return {};
  285. }
  286. ThrowCompletionOr<void> NewRegExp::execute_impl(Bytecode::Interpreter& interpreter) const
  287. {
  288. auto& vm = interpreter.vm();
  289. auto source = interpreter.current_executable().get_string(m_source_index);
  290. auto flags = interpreter.current_executable().get_string(m_flags_index);
  291. interpreter.accumulator() = TRY(regexp_create(vm, PrimitiveString::create(vm, source), PrimitiveString::create(vm, flags)));
  292. return {};
  293. }
  294. #define JS_DEFINE_NEW_BUILTIN_ERROR_OP(ErrorName) \
  295. ThrowCompletionOr<void> New##ErrorName::execute_impl(Bytecode::Interpreter& interpreter) const \
  296. { \
  297. auto& vm = interpreter.vm(); \
  298. auto& realm = *vm.current_realm(); \
  299. interpreter.accumulator() = MUST_OR_THROW_OOM(ErrorName::create(realm, interpreter.current_executable().get_string(m_error_string))); \
  300. return {}; \
  301. } \
  302. DeprecatedString New##ErrorName::to_deprecated_string_impl(Bytecode::Executable const& executable) const \
  303. { \
  304. return DeprecatedString::formatted("New" #ErrorName " {} (\"{}\")", m_error_string, executable.string_table->get(m_error_string)); \
  305. }
  306. JS_ENUMERATE_NEW_BUILTIN_ERROR_OPS(JS_DEFINE_NEW_BUILTIN_ERROR_OP)
  307. ThrowCompletionOr<void> CopyObjectExcludingProperties::execute_impl(Bytecode::Interpreter& interpreter) const
  308. {
  309. auto& vm = interpreter.vm();
  310. auto& realm = *vm.current_realm();
  311. auto from_object = interpreter.reg(m_from_object);
  312. auto to_object = Object::create(realm, realm.intrinsics().object_prototype());
  313. HashTable<PropertyKey> excluded_names;
  314. for (size_t i = 0; i < m_excluded_names_count; ++i) {
  315. excluded_names.set(TRY(interpreter.reg(m_excluded_names[i]).to_property_key(vm)));
  316. }
  317. TRY(to_object->copy_data_properties(vm, from_object, excluded_names));
  318. interpreter.accumulator() = to_object;
  319. return {};
  320. }
  321. ThrowCompletionOr<void> ConcatString::execute_impl(Bytecode::Interpreter& interpreter) const
  322. {
  323. auto& vm = interpreter.vm();
  324. auto string = TRY(interpreter.accumulator().to_primitive_string(vm));
  325. interpreter.reg(m_lhs) = PrimitiveString::create(vm, interpreter.reg(m_lhs).as_string(), string);
  326. return {};
  327. }
  328. ThrowCompletionOr<void> GetVariable::execute_impl(Bytecode::Interpreter& interpreter) const
  329. {
  330. auto& vm = interpreter.vm();
  331. auto get_reference = [&]() -> ThrowCompletionOr<Reference> {
  332. auto const& string = interpreter.current_executable().get_identifier(m_identifier);
  333. if (m_cached_environment_coordinate.has_value()) {
  334. Environment* environment = nullptr;
  335. bool coordinate_screwed_by_delete_in_global_environment = false;
  336. if (m_cached_environment_coordinate->index == EnvironmentCoordinate::global_marker) {
  337. environment = &interpreter.vm().current_realm()->global_environment();
  338. coordinate_screwed_by_delete_in_global_environment = !TRY(environment->has_binding(string));
  339. } else {
  340. environment = vm.running_execution_context().lexical_environment;
  341. for (size_t i = 0; i < m_cached_environment_coordinate->hops; ++i)
  342. environment = environment->outer_environment();
  343. VERIFY(environment);
  344. VERIFY(environment->is_declarative_environment());
  345. }
  346. if (!coordinate_screwed_by_delete_in_global_environment && !environment->is_permanently_screwed_by_eval()) {
  347. return Reference { *environment, string, vm.in_strict_mode(), m_cached_environment_coordinate };
  348. }
  349. m_cached_environment_coordinate = {};
  350. }
  351. auto reference = TRY(vm.resolve_binding(string));
  352. if (reference.environment_coordinate().has_value())
  353. m_cached_environment_coordinate = reference.environment_coordinate();
  354. return reference;
  355. };
  356. auto reference = TRY(get_reference());
  357. interpreter.accumulator() = TRY(reference.get_value(vm));
  358. return {};
  359. }
  360. ThrowCompletionOr<void> GetLocal::execute_impl(Bytecode::Interpreter& interpreter) const
  361. {
  362. auto& vm = interpreter.vm();
  363. if (vm.running_execution_context().local_variables[m_index].is_empty()) {
  364. auto const& variable_name = vm.running_execution_context().function->local_variables_names()[m_index];
  365. return interpreter.vm().throw_completion<ReferenceError>(ErrorType::BindingNotInitialized, variable_name);
  366. }
  367. interpreter.accumulator() = vm.running_execution_context().local_variables[m_index];
  368. return {};
  369. }
  370. ThrowCompletionOr<void> DeleteVariable::execute_impl(Bytecode::Interpreter& interpreter) const
  371. {
  372. auto& vm = interpreter.vm();
  373. auto const& string = interpreter.current_executable().get_identifier(m_identifier);
  374. auto reference = TRY(vm.resolve_binding(string));
  375. interpreter.accumulator() = Value(TRY(reference.delete_(vm)));
  376. return {};
  377. }
  378. ThrowCompletionOr<void> CreateLexicalEnvironment::execute_impl(Bytecode::Interpreter& interpreter) const
  379. {
  380. auto make_and_swap_envs = [&](auto& old_environment) {
  381. GCPtr<Environment> environment = new_declarative_environment(*old_environment).ptr();
  382. swap(old_environment, environment);
  383. return environment;
  384. };
  385. interpreter.saved_lexical_environment_stack().append(make_and_swap_envs(interpreter.vm().running_execution_context().lexical_environment));
  386. return {};
  387. }
  388. ThrowCompletionOr<void> EnterObjectEnvironment::execute_impl(Bytecode::Interpreter& interpreter) const
  389. {
  390. auto& vm = interpreter.vm();
  391. auto& old_environment = vm.running_execution_context().lexical_environment;
  392. interpreter.saved_lexical_environment_stack().append(old_environment);
  393. auto object = TRY(interpreter.accumulator().to_object(vm));
  394. vm.running_execution_context().lexical_environment = new_object_environment(object, true, old_environment);
  395. return {};
  396. }
  397. ThrowCompletionOr<void> CreateVariable::execute_impl(Bytecode::Interpreter& interpreter) const
  398. {
  399. auto& vm = interpreter.vm();
  400. auto const& name = interpreter.current_executable().get_identifier(m_identifier);
  401. if (m_mode == EnvironmentMode::Lexical) {
  402. VERIFY(!m_is_global);
  403. // Note: This is papering over an issue where "FunctionDeclarationInstantiation" creates these bindings for us.
  404. // Instead of crashing in there, we'll just raise an exception here.
  405. if (TRY(vm.lexical_environment()->has_binding(name)))
  406. return vm.throw_completion<InternalError>(TRY_OR_THROW_OOM(vm, String::formatted("Lexical environment already has binding '{}'", name)));
  407. if (m_is_immutable)
  408. return vm.lexical_environment()->create_immutable_binding(vm, name, vm.in_strict_mode());
  409. else
  410. return vm.lexical_environment()->create_mutable_binding(vm, name, vm.in_strict_mode());
  411. } else {
  412. if (!m_is_global) {
  413. if (m_is_immutable)
  414. return vm.variable_environment()->create_immutable_binding(vm, name, vm.in_strict_mode());
  415. else
  416. return vm.variable_environment()->create_mutable_binding(vm, name, vm.in_strict_mode());
  417. } else {
  418. // NOTE: CreateVariable with m_is_global set to true is expected to only be used in GlobalDeclarationInstantiation currently, which only uses "false" for "can_be_deleted".
  419. // The only area that sets "can_be_deleted" to true is EvalDeclarationInstantiation, which is currently fully implemented in C++ and not in Bytecode.
  420. return verify_cast<GlobalEnvironment>(vm.variable_environment())->create_global_var_binding(name, false);
  421. }
  422. }
  423. return {};
  424. }
  425. ThrowCompletionOr<void> SetVariable::execute_impl(Bytecode::Interpreter& interpreter) const
  426. {
  427. auto& vm = interpreter.vm();
  428. auto const& name = interpreter.current_executable().get_identifier(m_identifier);
  429. auto environment = m_mode == EnvironmentMode::Lexical ? vm.running_execution_context().lexical_environment : vm.running_execution_context().variable_environment;
  430. auto reference = TRY(vm.resolve_binding(name, environment));
  431. switch (m_initialization_mode) {
  432. case InitializationMode::Initialize:
  433. TRY(reference.initialize_referenced_binding(vm, interpreter.accumulator()));
  434. break;
  435. case InitializationMode::Set:
  436. TRY(reference.put_value(vm, interpreter.accumulator()));
  437. break;
  438. case InitializationMode::InitializeOrSet:
  439. VERIFY(reference.is_environment_reference());
  440. VERIFY(reference.base_environment().is_declarative_environment());
  441. TRY(static_cast<DeclarativeEnvironment&>(reference.base_environment()).initialize_or_set_mutable_binding(vm, name, interpreter.accumulator()));
  442. break;
  443. }
  444. return {};
  445. }
  446. ThrowCompletionOr<void> SetLocal::execute_impl(Bytecode::Interpreter& interpreter) const
  447. {
  448. interpreter.vm().running_execution_context().local_variables[m_index] = interpreter.accumulator();
  449. return {};
  450. }
  451. static ThrowCompletionOr<void> get_by_id(Bytecode::Interpreter& interpreter, IdentifierTableIndex property, Value base_value, Value this_value, u32 cache_index)
  452. {
  453. auto& vm = interpreter.vm();
  454. auto const& name = interpreter.current_executable().get_identifier(property);
  455. auto& cache = interpreter.current_executable().property_lookup_caches[cache_index];
  456. // OPTIMIZATION: For various primitives we can avoid actually creating a new object for them.
  457. GCPtr<Object> base_obj;
  458. if (base_value.is_object()) {
  459. // This would be covered by the `else` branch below,
  460. // but let's avoid all the extra checks if it's already an object.
  461. base_obj = base_value.as_object();
  462. } else if (base_value.is_string()) {
  463. auto string_value = TRY(base_value.as_string().get(vm, name));
  464. if (string_value.has_value()) {
  465. interpreter.accumulator() = *string_value;
  466. return {};
  467. }
  468. base_obj = vm.current_realm()->intrinsics().string_prototype();
  469. } else if (base_value.is_number()) {
  470. base_obj = vm.current_realm()->intrinsics().number_prototype();
  471. } else if (base_value.is_boolean()) {
  472. base_obj = vm.current_realm()->intrinsics().boolean_prototype();
  473. } else {
  474. base_obj = TRY(base_value.to_object(vm));
  475. }
  476. // OPTIMIZATION: If the shape of the object hasn't changed, we can use the cached property offset.
  477. if (&base_obj->shape() == cache.shape) {
  478. interpreter.accumulator() = base_obj->get_direct(cache.property_offset.value());
  479. return {};
  480. }
  481. CacheablePropertyMetadata cacheable_metadata;
  482. interpreter.accumulator() = TRY(base_obj->internal_get(name, this_value, &cacheable_metadata));
  483. if (cacheable_metadata.type == CacheablePropertyMetadata::Type::OwnProperty) {
  484. cache.shape = &base_obj->shape();
  485. cache.property_offset = cacheable_metadata.property_offset.value();
  486. } else {
  487. cache.shape = nullptr;
  488. cache.property_offset = {};
  489. }
  490. return {};
  491. }
  492. ThrowCompletionOr<void> GetById::execute_impl(Bytecode::Interpreter& interpreter) const
  493. {
  494. auto base_value = interpreter.accumulator();
  495. return get_by_id(interpreter, m_property, base_value, base_value, m_cache_index);
  496. }
  497. ThrowCompletionOr<void> GetByIdWithThis::execute_impl(Bytecode::Interpreter& interpreter) const
  498. {
  499. auto base_value = interpreter.accumulator();
  500. auto this_value = interpreter.reg(m_this_value);
  501. return get_by_id(interpreter, m_property, base_value, this_value, m_cache_index);
  502. }
  503. ThrowCompletionOr<void> GetPrivateById::execute_impl(Bytecode::Interpreter& interpreter) const
  504. {
  505. auto& vm = interpreter.vm();
  506. auto const& name = interpreter.current_executable().get_identifier(m_property);
  507. auto base_value = interpreter.accumulator();
  508. auto private_reference = make_private_reference(vm, base_value, name);
  509. interpreter.accumulator() = TRY(private_reference.get_value(vm));
  510. return {};
  511. }
  512. ThrowCompletionOr<void> HasPrivateId::execute_impl(Bytecode::Interpreter& interpreter) const
  513. {
  514. auto& vm = interpreter.vm();
  515. if (!interpreter.accumulator().is_object())
  516. return vm.throw_completion<TypeError>(ErrorType::InOperatorWithObject);
  517. auto private_environment = vm.running_execution_context().private_environment;
  518. VERIFY(private_environment);
  519. auto private_name = private_environment->resolve_private_identifier(interpreter.current_executable().get_identifier(m_property));
  520. interpreter.accumulator() = Value(interpreter.accumulator().as_object().private_element_find(private_name) != nullptr);
  521. return {};
  522. }
  523. ThrowCompletionOr<void> PutById::execute_impl(Bytecode::Interpreter& interpreter) const
  524. {
  525. auto& vm = interpreter.vm();
  526. // NOTE: Get the value from the accumulator before side effects have a chance to overwrite it.
  527. auto value = interpreter.accumulator();
  528. auto base = interpreter.reg(m_base);
  529. PropertyKey name = interpreter.current_executable().get_identifier(m_property);
  530. TRY(put_by_property_key(vm, base, base, value, name, m_kind));
  531. interpreter.accumulator() = value;
  532. return {};
  533. }
  534. ThrowCompletionOr<void> PutByIdWithThis::execute_impl(Bytecode::Interpreter& interpreter) const
  535. {
  536. auto& vm = interpreter.vm();
  537. // NOTE: Get the value from the accumulator before side effects have a chance to overwrite it.
  538. auto value = interpreter.accumulator();
  539. auto base = interpreter.reg(m_base);
  540. PropertyKey name = interpreter.current_executable().get_identifier(m_property);
  541. TRY(put_by_property_key(vm, base, interpreter.reg(m_this_value), value, name, m_kind));
  542. interpreter.accumulator() = value;
  543. return {};
  544. }
  545. ThrowCompletionOr<void> PutPrivateById::execute_impl(Bytecode::Interpreter& interpreter) const
  546. {
  547. auto& vm = interpreter.vm();
  548. // NOTE: Get the value from the accumulator before side effects have a chance to overwrite it.
  549. auto value = interpreter.accumulator();
  550. auto object = TRY(interpreter.reg(m_base).to_object(vm));
  551. auto name = interpreter.current_executable().get_identifier(m_property);
  552. auto private_reference = make_private_reference(vm, object, name);
  553. TRY(private_reference.put_value(vm, value));
  554. interpreter.accumulator() = value;
  555. return {};
  556. }
  557. ThrowCompletionOr<void> DeleteById::execute_impl(Bytecode::Interpreter& interpreter) const
  558. {
  559. auto& vm = interpreter.vm();
  560. auto base_value = interpreter.accumulator();
  561. auto const& identifier = interpreter.current_executable().get_identifier(m_property);
  562. bool strict = vm.in_strict_mode();
  563. auto reference = Reference { base_value, identifier, {}, strict };
  564. interpreter.accumulator() = Value(TRY(reference.delete_(vm)));
  565. return {};
  566. }
  567. ThrowCompletionOr<void> DeleteByIdWithThis::execute_impl(Bytecode::Interpreter& interpreter) const
  568. {
  569. auto& vm = interpreter.vm();
  570. auto base_value = interpreter.accumulator();
  571. auto const& identifier = interpreter.current_executable().get_identifier(m_property);
  572. bool strict = vm.in_strict_mode();
  573. auto reference = Reference { base_value, identifier, interpreter.reg(m_this_value), strict };
  574. interpreter.accumulator() = Value(TRY(reference.delete_(vm)));
  575. return {};
  576. }
  577. ThrowCompletionOr<void> Jump::execute_impl(Bytecode::Interpreter& interpreter) const
  578. {
  579. interpreter.jump(*m_true_target);
  580. return {};
  581. }
  582. ThrowCompletionOr<void> ResolveThisBinding::execute_impl(Bytecode::Interpreter& interpreter) const
  583. {
  584. auto& vm = interpreter.vm();
  585. interpreter.accumulator() = TRY(vm.resolve_this_binding());
  586. return {};
  587. }
  588. // https://tc39.es/ecma262/#sec-makesuperpropertyreference
  589. ThrowCompletionOr<void> ResolveSuperBase::execute_impl(Bytecode::Interpreter& interpreter) const
  590. {
  591. auto& vm = interpreter.vm();
  592. // 1. Let env be GetThisEnvironment().
  593. auto& env = verify_cast<FunctionEnvironment>(*get_this_environment(vm));
  594. // 2. Assert: env.HasSuperBinding() is true.
  595. VERIFY(env.has_super_binding());
  596. // 3. Let baseValue be ? env.GetSuperBase().
  597. interpreter.accumulator() = TRY(env.get_super_base());
  598. return {};
  599. }
  600. ThrowCompletionOr<void> GetNewTarget::execute_impl(Bytecode::Interpreter& interpreter) const
  601. {
  602. interpreter.accumulator() = interpreter.vm().get_new_target();
  603. return {};
  604. }
  605. void Jump::replace_references_impl(BasicBlock const& from, BasicBlock const& to)
  606. {
  607. if (m_true_target.has_value() && &m_true_target->block() == &from)
  608. m_true_target = Label { to };
  609. if (m_false_target.has_value() && &m_false_target->block() == &from)
  610. m_false_target = Label { to };
  611. }
  612. ThrowCompletionOr<void> JumpConditional::execute_impl(Bytecode::Interpreter& interpreter) const
  613. {
  614. VERIFY(m_true_target.has_value());
  615. VERIFY(m_false_target.has_value());
  616. auto result = interpreter.accumulator();
  617. if (result.to_boolean())
  618. interpreter.jump(m_true_target.value());
  619. else
  620. interpreter.jump(m_false_target.value());
  621. return {};
  622. }
  623. ThrowCompletionOr<void> JumpNullish::execute_impl(Bytecode::Interpreter& interpreter) const
  624. {
  625. VERIFY(m_true_target.has_value());
  626. VERIFY(m_false_target.has_value());
  627. auto result = interpreter.accumulator();
  628. if (result.is_nullish())
  629. interpreter.jump(m_true_target.value());
  630. else
  631. interpreter.jump(m_false_target.value());
  632. return {};
  633. }
  634. ThrowCompletionOr<void> JumpUndefined::execute_impl(Bytecode::Interpreter& interpreter) const
  635. {
  636. VERIFY(m_true_target.has_value());
  637. VERIFY(m_false_target.has_value());
  638. auto result = interpreter.accumulator();
  639. if (result.is_undefined())
  640. interpreter.jump(m_true_target.value());
  641. else
  642. interpreter.jump(m_false_target.value());
  643. return {};
  644. }
  645. // 13.3.8.1 https://tc39.es/ecma262/#sec-runtime-semantics-argumentlistevaluation
  646. static MarkedVector<Value> argument_list_evaluation(Bytecode::Interpreter& interpreter)
  647. {
  648. // Note: Any spreading and actual evaluation is handled in preceding opcodes
  649. // Note: The spec uses the concept of a list, while we create a temporary array
  650. // in the preceding opcodes, so we have to convert in a manner that is not
  651. // visible to the user
  652. auto& vm = interpreter.vm();
  653. MarkedVector<Value> argument_values { vm.heap() };
  654. auto arguments = interpreter.accumulator();
  655. if (!(arguments.is_object() && is<Array>(arguments.as_object()))) {
  656. dbgln("[{}] Call arguments are not an array, but: {}", interpreter.debug_position(), MUST(arguments.to_string_without_side_effects()));
  657. interpreter.current_executable().dump();
  658. VERIFY_NOT_REACHED();
  659. }
  660. auto& argument_array = arguments.as_array();
  661. auto array_length = argument_array.indexed_properties().array_like_size();
  662. argument_values.ensure_capacity(array_length);
  663. for (size_t i = 0; i < array_length; ++i) {
  664. if (auto maybe_value = argument_array.indexed_properties().get(i); maybe_value.has_value())
  665. argument_values.append(maybe_value.release_value().value);
  666. else
  667. argument_values.append(js_undefined());
  668. }
  669. return argument_values;
  670. }
  671. static Completion throw_type_error_for_callee(Bytecode::Interpreter& interpreter, auto& call, StringView callee_type)
  672. {
  673. auto& vm = interpreter.vm();
  674. auto callee = interpreter.reg(call.callee());
  675. if (call.expression_string().has_value())
  676. return vm.throw_completion<TypeError>(ErrorType::IsNotAEvaluatedFrom, TRY_OR_THROW_OOM(vm, callee.to_string_without_side_effects()), callee_type, interpreter.current_executable().get_string(call.expression_string()->value()));
  677. return vm.throw_completion<TypeError>(ErrorType::IsNotA, TRY_OR_THROW_OOM(vm, callee.to_string_without_side_effects()), callee_type);
  678. }
  679. static ThrowCompletionOr<void> throw_if_needed_for_call(Interpreter& interpreter, auto& call, Value callee)
  680. {
  681. if (call.call_type() == CallType::Call && !callee.is_function())
  682. return throw_type_error_for_callee(interpreter, call, "function"sv);
  683. if (call.call_type() == CallType::Construct && !callee.is_constructor())
  684. return throw_type_error_for_callee(interpreter, call, "constructor"sv);
  685. return {};
  686. }
  687. static ThrowCompletionOr<void> perform_call(Interpreter& interpreter, auto& call, Value callee, MarkedVector<Value> argument_values)
  688. {
  689. auto& vm = interpreter.vm();
  690. auto this_value = interpreter.reg(call.this_value());
  691. auto& function = callee.as_function();
  692. Value return_value;
  693. if (call.call_type() == CallType::DirectEval) {
  694. if (callee == interpreter.realm().intrinsics().eval_function())
  695. return_value = TRY(perform_eval(vm, !argument_values.is_empty() ? argument_values[0].value_or(JS::js_undefined()) : js_undefined(), vm.in_strict_mode() ? CallerMode::Strict : CallerMode::NonStrict, EvalMode::Direct));
  696. else
  697. return_value = TRY(JS::call(vm, function, this_value, move(argument_values)));
  698. } else if (call.call_type() == CallType::Call)
  699. return_value = TRY(JS::call(vm, function, this_value, move(argument_values)));
  700. else
  701. return_value = TRY(construct(vm, function, move(argument_values)));
  702. interpreter.accumulator() = return_value;
  703. return {};
  704. }
  705. ThrowCompletionOr<void> Call::execute_impl(Bytecode::Interpreter& interpreter) const
  706. {
  707. auto& vm = interpreter.vm();
  708. auto callee = interpreter.reg(m_callee);
  709. TRY(throw_if_needed_for_call(interpreter, *this, callee));
  710. MarkedVector<Value> argument_values(vm.heap());
  711. argument_values.ensure_capacity(m_argument_count);
  712. for (u32 i = 0; i < m_argument_count; ++i) {
  713. argument_values.unchecked_append(interpreter.reg(Register { m_first_argument.index() + i }));
  714. }
  715. return perform_call(interpreter, *this, callee, move(argument_values));
  716. }
  717. ThrowCompletionOr<void> CallWithArgumentArray::execute_impl(Bytecode::Interpreter& interpreter) const
  718. {
  719. auto callee = interpreter.reg(m_callee);
  720. TRY(throw_if_needed_for_call(interpreter, *this, callee));
  721. auto argument_values = argument_list_evaluation(interpreter);
  722. return perform_call(interpreter, *this, callee, move(argument_values));
  723. }
  724. // 13.3.7.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-super-keyword-runtime-semantics-evaluation
  725. ThrowCompletionOr<void> SuperCallWithArgumentArray::execute_impl(Bytecode::Interpreter& interpreter) const
  726. {
  727. auto& vm = interpreter.vm();
  728. // 1. Let newTarget be GetNewTarget().
  729. auto new_target = vm.get_new_target();
  730. // 2. Assert: Type(newTarget) is Object.
  731. VERIFY(new_target.is_object());
  732. // 3. Let func be GetSuperConstructor().
  733. auto* func = get_super_constructor(vm);
  734. // 4. Let argList be ? ArgumentListEvaluation of Arguments.
  735. MarkedVector<Value> arg_list { vm.heap() };
  736. if (m_is_synthetic) {
  737. auto const& value = interpreter.accumulator();
  738. VERIFY(value.is_object() && is<Array>(value.as_object()));
  739. auto const& array_value = static_cast<Array const&>(value.as_object());
  740. auto length = MUST(length_of_array_like(vm, array_value));
  741. for (size_t i = 0; i < length; ++i)
  742. arg_list.append(array_value.get_without_side_effects(PropertyKey { i }));
  743. } else {
  744. arg_list = argument_list_evaluation(interpreter);
  745. }
  746. // 5. If IsConstructor(func) is false, throw a TypeError exception.
  747. if (!Value(func).is_constructor())
  748. return vm.throw_completion<TypeError>(ErrorType::NotAConstructor, "Super constructor");
  749. // 6. Let result be ? Construct(func, argList, newTarget).
  750. auto result = TRY(construct(vm, static_cast<FunctionObject&>(*func), move(arg_list), &new_target.as_function()));
  751. // 7. Let thisER be GetThisEnvironment().
  752. auto& this_environment = verify_cast<FunctionEnvironment>(*get_this_environment(vm));
  753. // 8. Perform ? thisER.BindThisValue(result).
  754. TRY(this_environment.bind_this_value(vm, result));
  755. // 9. Let F be thisER.[[FunctionObject]].
  756. auto& f = this_environment.function_object();
  757. // 10. Assert: F is an ECMAScript function object.
  758. // NOTE: This is implied by the strong C++ type.
  759. // 11. Perform ? InitializeInstanceElements(result, F).
  760. TRY(result->initialize_instance_elements(f));
  761. // 12. Return result.
  762. interpreter.accumulator() = result;
  763. return {};
  764. }
  765. ThrowCompletionOr<void> NewFunction::execute_impl(Bytecode::Interpreter& interpreter) const
  766. {
  767. auto& vm = interpreter.vm();
  768. if (!m_function_node.has_name()) {
  769. DeprecatedFlyString name = {};
  770. if (m_lhs_name.has_value())
  771. name = interpreter.current_executable().get_identifier(m_lhs_name.value());
  772. interpreter.accumulator() = m_function_node.instantiate_ordinary_function_expression(vm, name);
  773. } else {
  774. interpreter.accumulator() = ECMAScriptFunctionObject::create(interpreter.realm(), m_function_node.name(), m_function_node.source_text(), m_function_node.body(), m_function_node.parameters(), m_function_node.function_length(), m_function_node.local_variables_names(), vm.lexical_environment(), vm.running_execution_context().private_environment, m_function_node.kind(), m_function_node.is_strict_mode(), m_function_node.might_need_arguments_object(), m_function_node.contains_direct_call_to_eval(), m_function_node.is_arrow_function());
  775. }
  776. if (m_home_object.has_value()) {
  777. auto home_object_value = interpreter.reg(m_home_object.value());
  778. static_cast<ECMAScriptFunctionObject&>(interpreter.accumulator().as_function()).set_home_object(&home_object_value.as_object());
  779. }
  780. return {};
  781. }
  782. ThrowCompletionOr<void> Return::execute_impl(Bytecode::Interpreter& interpreter) const
  783. {
  784. interpreter.do_return(interpreter.accumulator().value_or(js_undefined()));
  785. return {};
  786. }
  787. ThrowCompletionOr<void> Increment::execute_impl(Bytecode::Interpreter& interpreter) const
  788. {
  789. auto& vm = interpreter.vm();
  790. auto old_value = TRY(interpreter.accumulator().to_numeric(vm));
  791. if (old_value.is_number())
  792. interpreter.accumulator() = Value(old_value.as_double() + 1);
  793. else
  794. interpreter.accumulator() = BigInt::create(vm, old_value.as_bigint().big_integer().plus(Crypto::SignedBigInteger { 1 }));
  795. return {};
  796. }
  797. ThrowCompletionOr<void> Decrement::execute_impl(Bytecode::Interpreter& interpreter) const
  798. {
  799. auto& vm = interpreter.vm();
  800. auto old_value = TRY(interpreter.accumulator().to_numeric(vm));
  801. if (old_value.is_number())
  802. interpreter.accumulator() = Value(old_value.as_double() - 1);
  803. else
  804. interpreter.accumulator() = BigInt::create(vm, old_value.as_bigint().big_integer().minus(Crypto::SignedBigInteger { 1 }));
  805. return {};
  806. }
  807. ThrowCompletionOr<void> Throw::execute_impl(Bytecode::Interpreter& interpreter) const
  808. {
  809. return throw_completion(interpreter.accumulator());
  810. }
  811. ThrowCompletionOr<void> ThrowIfNotObject::execute_impl(Bytecode::Interpreter& interpreter) const
  812. {
  813. auto& vm = interpreter.vm();
  814. if (!interpreter.accumulator().is_object())
  815. return vm.throw_completion<TypeError>(ErrorType::NotAnObject, TRY_OR_THROW_OOM(vm, interpreter.accumulator().to_string_without_side_effects()));
  816. return {};
  817. }
  818. ThrowCompletionOr<void> ThrowIfNullish::execute_impl(Bytecode::Interpreter& interpreter) const
  819. {
  820. auto& vm = interpreter.vm();
  821. auto value = interpreter.accumulator();
  822. if (value.is_nullish())
  823. return vm.throw_completion<TypeError>(ErrorType::NotObjectCoercible, TRY_OR_THROW_OOM(vm, value.to_string_without_side_effects()));
  824. return {};
  825. }
  826. ThrowCompletionOr<void> EnterUnwindContext::execute_impl(Bytecode::Interpreter& interpreter) const
  827. {
  828. interpreter.enter_unwind_context(m_handler_target, m_finalizer_target);
  829. interpreter.jump(m_entry_point);
  830. return {};
  831. }
  832. void NewFunction::replace_references_impl(Register from, Register to)
  833. {
  834. if (m_home_object == from)
  835. m_home_object = to;
  836. }
  837. void EnterUnwindContext::replace_references_impl(BasicBlock const& from, BasicBlock const& to)
  838. {
  839. if (&m_entry_point.block() == &from)
  840. m_entry_point = Label { to };
  841. if (m_handler_target.has_value() && &m_handler_target->block() == &from)
  842. m_handler_target = Label { to };
  843. if (m_finalizer_target.has_value() && &m_finalizer_target->block() == &from)
  844. m_finalizer_target = Label { to };
  845. }
  846. void CopyObjectExcludingProperties::replace_references_impl(Register from, Register to)
  847. {
  848. if (m_from_object == from)
  849. m_from_object = to;
  850. for (size_t i = 0; i < m_excluded_names_count; ++i) {
  851. if (m_excluded_names[i] == from)
  852. m_excluded_names[i] = to;
  853. }
  854. }
  855. void Call::replace_references_impl(Register from, Register to)
  856. {
  857. if (m_callee == from)
  858. m_callee = to;
  859. if (m_this_value == from)
  860. m_this_value = to;
  861. if (m_first_argument == from)
  862. m_first_argument = to;
  863. }
  864. void CallWithArgumentArray::replace_references_impl(Register from, Register to)
  865. {
  866. if (m_callee == from)
  867. m_callee = to;
  868. if (m_this_value == from)
  869. m_this_value = to;
  870. }
  871. ThrowCompletionOr<void> ScheduleJump::execute_impl(Bytecode::Interpreter& interpreter) const
  872. {
  873. interpreter.schedule_jump(m_target);
  874. return {};
  875. }
  876. ThrowCompletionOr<void> LeaveLexicalEnvironment::execute_impl(Bytecode::Interpreter& interpreter) const
  877. {
  878. interpreter.vm().running_execution_context().lexical_environment = interpreter.saved_lexical_environment_stack().take_last();
  879. return {};
  880. }
  881. ThrowCompletionOr<void> LeaveUnwindContext::execute_impl(Bytecode::Interpreter& interpreter) const
  882. {
  883. interpreter.leave_unwind_context();
  884. return {};
  885. }
  886. ThrowCompletionOr<void> ContinuePendingUnwind::execute_impl(Bytecode::Interpreter& interpreter) const
  887. {
  888. return interpreter.continue_pending_unwind(m_resume_target);
  889. }
  890. void ContinuePendingUnwind::replace_references_impl(BasicBlock const& from, BasicBlock const& to)
  891. {
  892. if (&m_resume_target.block() == &from)
  893. m_resume_target = Label { to };
  894. }
  895. ThrowCompletionOr<void> PushDeclarativeEnvironment::execute_impl(Bytecode::Interpreter& interpreter) const
  896. {
  897. auto environment = interpreter.vm().heap().allocate_without_realm<DeclarativeEnvironment>(interpreter.vm().lexical_environment());
  898. interpreter.vm().running_execution_context().lexical_environment = environment;
  899. interpreter.vm().running_execution_context().variable_environment = environment;
  900. return {};
  901. }
  902. ThrowCompletionOr<void> Yield::execute_impl(Bytecode::Interpreter& interpreter) const
  903. {
  904. auto yielded_value = interpreter.accumulator().value_or(js_undefined());
  905. auto object = Object::create(interpreter.realm(), nullptr);
  906. object->define_direct_property("result", yielded_value, JS::default_attributes);
  907. if (m_continuation_label.has_value())
  908. // FIXME: If we get a pointer, which is not accurately representable as a double
  909. // will cause this to explode
  910. object->define_direct_property("continuation", Value(static_cast<double>(reinterpret_cast<u64>(&m_continuation_label->block()))), JS::default_attributes);
  911. else
  912. object->define_direct_property("continuation", Value(0), JS::default_attributes);
  913. interpreter.do_return(object);
  914. return {};
  915. }
  916. void Yield::replace_references_impl(BasicBlock const& from, BasicBlock const& to)
  917. {
  918. if (m_continuation_label.has_value() && &m_continuation_label->block() == &from)
  919. m_continuation_label = Label { to };
  920. }
  921. ThrowCompletionOr<void> GetByValue::execute_impl(Bytecode::Interpreter& interpreter) const
  922. {
  923. auto& vm = interpreter.vm();
  924. // NOTE: Get the property key from the accumulator before side effects have a chance to overwrite it.
  925. auto property_key_value = interpreter.accumulator();
  926. auto object = TRY(interpreter.reg(m_base).to_object(vm));
  927. auto property_key = TRY(property_key_value.to_property_key(vm));
  928. interpreter.accumulator() = TRY(object->get(property_key));
  929. return {};
  930. }
  931. ThrowCompletionOr<void> GetByValueWithThis::execute_impl(Bytecode::Interpreter& interpreter) const
  932. {
  933. auto& vm = interpreter.vm();
  934. // NOTE: Get the property key from the accumulator before side effects have a chance to overwrite it.
  935. auto property_key_value = interpreter.accumulator();
  936. auto object = TRY(interpreter.reg(m_base).to_object(vm));
  937. auto property_key = TRY(property_key_value.to_property_key(vm));
  938. interpreter.accumulator() = TRY(object->internal_get(property_key, interpreter.reg(m_this_value)));
  939. return {};
  940. }
  941. ThrowCompletionOr<void> PutByValue::execute_impl(Bytecode::Interpreter& interpreter) const
  942. {
  943. auto& vm = interpreter.vm();
  944. // NOTE: Get the value from the accumulator before side effects have a chance to overwrite it.
  945. auto value = interpreter.accumulator();
  946. auto base = interpreter.reg(m_base);
  947. auto property_key = TRY(interpreter.reg(m_property).to_property_key(vm));
  948. TRY(put_by_property_key(vm, base, base, value, property_key, m_kind));
  949. interpreter.accumulator() = value;
  950. return {};
  951. }
  952. ThrowCompletionOr<void> PutByValueWithThis::execute_impl(Bytecode::Interpreter& interpreter) const
  953. {
  954. auto& vm = interpreter.vm();
  955. // NOTE: Get the value from the accumulator before side effects have a chance to overwrite it.
  956. auto value = interpreter.accumulator();
  957. auto base = interpreter.reg(m_base);
  958. auto property_key = TRY(interpreter.reg(m_property).to_property_key(vm));
  959. TRY(put_by_property_key(vm, base, interpreter.reg(m_this_value), value, property_key, m_kind));
  960. interpreter.accumulator() = value;
  961. return {};
  962. }
  963. ThrowCompletionOr<void> DeleteByValue::execute_impl(Bytecode::Interpreter& interpreter) const
  964. {
  965. auto& vm = interpreter.vm();
  966. // NOTE: Get the property key from the accumulator before side effects have a chance to overwrite it.
  967. auto property_key_value = interpreter.accumulator();
  968. auto base_value = interpreter.reg(m_base);
  969. auto property_key = TRY(property_key_value.to_property_key(vm));
  970. bool strict = vm.in_strict_mode();
  971. auto reference = Reference { base_value, property_key, {}, strict };
  972. interpreter.accumulator() = Value(TRY(reference.delete_(vm)));
  973. return {};
  974. }
  975. ThrowCompletionOr<void> DeleteByValueWithThis::execute_impl(Bytecode::Interpreter& interpreter) const
  976. {
  977. auto& vm = interpreter.vm();
  978. // NOTE: Get the property key from the accumulator before side effects have a chance to overwrite it.
  979. auto property_key_value = interpreter.accumulator();
  980. auto base_value = interpreter.reg(m_base);
  981. auto property_key = TRY(property_key_value.to_property_key(vm));
  982. bool strict = vm.in_strict_mode();
  983. auto reference = Reference { base_value, property_key, interpreter.reg(m_this_value), strict };
  984. interpreter.accumulator() = Value(TRY(reference.delete_(vm)));
  985. return {};
  986. }
  987. ThrowCompletionOr<void> GetIterator::execute_impl(Bytecode::Interpreter& interpreter) const
  988. {
  989. auto& vm = interpreter.vm();
  990. auto iterator = TRY(get_iterator(vm, interpreter.accumulator(), m_hint));
  991. interpreter.accumulator() = iterator_to_object(vm, iterator);
  992. return {};
  993. }
  994. ThrowCompletionOr<void> GetMethod::execute_impl(Bytecode::Interpreter& interpreter) const
  995. {
  996. auto& vm = interpreter.vm();
  997. auto identifier = interpreter.current_executable().get_identifier(m_property);
  998. auto method = TRY(interpreter.accumulator().get_method(vm, identifier));
  999. interpreter.accumulator() = method ?: js_undefined();
  1000. return {};
  1001. }
  1002. // 14.7.5.9 EnumerateObjectProperties ( O ), https://tc39.es/ecma262/#sec-enumerate-object-properties
  1003. ThrowCompletionOr<void> GetObjectPropertyIterator::execute_impl(Bytecode::Interpreter& interpreter) const
  1004. {
  1005. // While the spec does provide an algorithm, it allows us to implement it ourselves so long as we meet the following invariants:
  1006. // 1- Returned property keys do not include keys that are Symbols
  1007. // 2- Properties of the target object may be deleted during enumeration. A property that is deleted before it is processed by the iterator's next method is ignored
  1008. // 3- If new properties are added to the target object during enumeration, the newly added properties are not guaranteed to be processed in the active enumeration
  1009. // 4- A property name will be returned by the iterator's next method at most once in any enumeration.
  1010. // 5- Enumerating the properties of the target object includes enumerating properties of its prototype, and the prototype of the prototype, and so on, recursively;
  1011. // but a property of a prototype is not processed if it has the same name as a property that has already been processed by the iterator's next method.
  1012. // 6- The values of [[Enumerable]] attributes are not considered when determining if a property of a prototype object has already been processed.
  1013. // 7- The enumerable property names of prototype objects must be obtained by invoking EnumerateObjectProperties passing the prototype object as the argument.
  1014. // 8- EnumerateObjectProperties must obtain the own property keys of the target object by calling its [[OwnPropertyKeys]] internal method.
  1015. // 9- Property attributes of the target object must be obtained by calling its [[GetOwnProperty]] internal method
  1016. // Invariant 3 effectively allows the implementation to ignore newly added keys, and we do so (similar to other implementations).
  1017. auto& vm = interpreter.vm();
  1018. auto object = TRY(interpreter.accumulator().to_object(vm));
  1019. // Note: While the spec doesn't explicitly require these to be ordered, it says that the values should be retrieved via OwnPropertyKeys,
  1020. // so we just keep the order consistent anyway.
  1021. OrderedHashTable<PropertyKey> properties;
  1022. OrderedHashTable<PropertyKey> non_enumerable_properties;
  1023. HashTable<NonnullGCPtr<Object>> seen_objects;
  1024. // Collect all keys immediately (invariant no. 5)
  1025. for (auto object_to_check = GCPtr { object.ptr() }; object_to_check && !seen_objects.contains(*object_to_check); object_to_check = TRY(object_to_check->internal_get_prototype_of())) {
  1026. seen_objects.set(*object_to_check);
  1027. for (auto& key : TRY(object_to_check->internal_own_property_keys())) {
  1028. if (key.is_symbol())
  1029. continue;
  1030. auto property_key = TRY(PropertyKey::from_value(vm, key));
  1031. // If there is a non-enumerable property higher up the prototype chain with the same key,
  1032. // we mustn't include this property even if it's enumerable (invariant no. 5 and 6)
  1033. if (non_enumerable_properties.contains(property_key))
  1034. continue;
  1035. if (properties.contains(property_key))
  1036. continue;
  1037. auto descriptor = TRY(object_to_check->internal_get_own_property(property_key));
  1038. if (!*descriptor->enumerable)
  1039. non_enumerable_properties.set(move(property_key));
  1040. else
  1041. properties.set(move(property_key));
  1042. }
  1043. }
  1044. IteratorRecord iterator {
  1045. .iterator = object,
  1046. .next_method = NativeFunction::create(
  1047. interpreter.realm(),
  1048. [items = move(properties)](VM& vm) mutable -> ThrowCompletionOr<Value> {
  1049. auto& realm = *vm.current_realm();
  1050. auto iterated_object_value = vm.this_value();
  1051. if (!iterated_object_value.is_object())
  1052. return vm.throw_completion<InternalError>("Invalid state for GetObjectPropertyIterator.next"sv);
  1053. auto& iterated_object = iterated_object_value.as_object();
  1054. auto result_object = Object::create(realm, nullptr);
  1055. while (true) {
  1056. if (items.is_empty()) {
  1057. result_object->define_direct_property(vm.names.done, JS::Value(true), default_attributes);
  1058. return result_object;
  1059. }
  1060. auto key = items.take_first();
  1061. // If the property is deleted, don't include it (invariant no. 2)
  1062. if (!TRY(iterated_object.has_property(key)))
  1063. continue;
  1064. result_object->define_direct_property(vm.names.done, JS::Value(false), default_attributes);
  1065. if (key.is_number())
  1066. result_object->define_direct_property(vm.names.value, PrimitiveString::create(vm, TRY_OR_THROW_OOM(vm, String::number(key.as_number()))), default_attributes);
  1067. else if (key.is_string())
  1068. result_object->define_direct_property(vm.names.value, PrimitiveString::create(vm, key.as_string()), default_attributes);
  1069. else
  1070. VERIFY_NOT_REACHED(); // We should not have non-string/number keys.
  1071. return result_object;
  1072. }
  1073. },
  1074. 1,
  1075. vm.names.next),
  1076. .done = false,
  1077. };
  1078. interpreter.accumulator() = iterator_to_object(vm, move(iterator));
  1079. return {};
  1080. }
  1081. ThrowCompletionOr<void> IteratorClose::execute_impl(Bytecode::Interpreter& interpreter) const
  1082. {
  1083. auto& vm = interpreter.vm();
  1084. auto iterator_object = TRY(interpreter.accumulator().to_object(vm));
  1085. auto iterator = object_to_iterator(vm, iterator_object);
  1086. // FIXME: Return the value of the resulting completion. (Note that m_completion_value can be empty!)
  1087. TRY(iterator_close(vm, iterator, Completion { m_completion_type, m_completion_value, {} }));
  1088. return {};
  1089. }
  1090. ThrowCompletionOr<void> IteratorNext::execute_impl(Bytecode::Interpreter& interpreter) const
  1091. {
  1092. auto& vm = interpreter.vm();
  1093. auto iterator_object = TRY(interpreter.accumulator().to_object(vm));
  1094. auto iterator = object_to_iterator(vm, iterator_object);
  1095. interpreter.accumulator() = TRY(iterator_next(vm, iterator));
  1096. return {};
  1097. }
  1098. ThrowCompletionOr<void> IteratorResultDone::execute_impl(Bytecode::Interpreter& interpreter) const
  1099. {
  1100. auto& vm = interpreter.vm();
  1101. auto iterator_result = TRY(interpreter.accumulator().to_object(vm));
  1102. auto complete = TRY(iterator_complete(vm, iterator_result));
  1103. interpreter.accumulator() = Value(complete);
  1104. return {};
  1105. }
  1106. ThrowCompletionOr<void> IteratorResultValue::execute_impl(Bytecode::Interpreter& interpreter) const
  1107. {
  1108. auto& vm = interpreter.vm();
  1109. auto iterator_result = TRY(interpreter.accumulator().to_object(vm));
  1110. interpreter.accumulator() = TRY(iterator_value(vm, iterator_result));
  1111. return {};
  1112. }
  1113. ThrowCompletionOr<void> NewClass::execute_impl(Bytecode::Interpreter& interpreter) const
  1114. {
  1115. auto& vm = interpreter.vm();
  1116. auto name = m_class_expression.name();
  1117. auto super_class = interpreter.accumulator();
  1118. // NOTE: NewClass expects classEnv to be active lexical environment
  1119. auto class_environment = vm.lexical_environment();
  1120. vm.running_execution_context().lexical_environment = interpreter.saved_lexical_environment_stack().take_last();
  1121. DeprecatedFlyString binding_name;
  1122. DeprecatedFlyString class_name;
  1123. if (!m_class_expression.has_name() && m_lhs_name.has_value()) {
  1124. class_name = interpreter.current_executable().get_identifier(m_lhs_name.value());
  1125. } else {
  1126. binding_name = name;
  1127. class_name = name.is_null() ? ""sv : name;
  1128. }
  1129. interpreter.accumulator() = TRY(m_class_expression.create_class_constructor(vm, class_environment, vm.lexical_environment(), super_class, binding_name, class_name));
  1130. return {};
  1131. }
  1132. // 13.5.3.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-typeof-operator-runtime-semantics-evaluation
  1133. ThrowCompletionOr<void> TypeofVariable::execute_impl(Bytecode::Interpreter& interpreter) const
  1134. {
  1135. auto& vm = interpreter.vm();
  1136. // 1. Let val be the result of evaluating UnaryExpression.
  1137. auto const& string = interpreter.current_executable().get_identifier(m_identifier);
  1138. auto reference = TRY(vm.resolve_binding(string));
  1139. // 2. If val is a Reference Record, then
  1140. // a. If IsUnresolvableReference(val) is true, return "undefined".
  1141. if (reference.is_unresolvable()) {
  1142. interpreter.accumulator() = MUST_OR_THROW_OOM(PrimitiveString::create(vm, "undefined"sv));
  1143. return {};
  1144. }
  1145. // 3. Set val to ? GetValue(val).
  1146. auto value = TRY(reference.get_value(vm));
  1147. // 4. NOTE: This step is replaced in section B.3.6.3.
  1148. // 5. Return a String according to Table 41.
  1149. interpreter.accumulator() = MUST_OR_THROW_OOM(PrimitiveString::create(vm, value.typeof()));
  1150. return {};
  1151. }
  1152. ThrowCompletionOr<void> TypeofLocal::execute_impl(Bytecode::Interpreter& interpreter) const
  1153. {
  1154. auto& vm = interpreter.vm();
  1155. auto const& value = vm.running_execution_context().local_variables[m_index];
  1156. interpreter.accumulator() = MUST_OR_THROW_OOM(PrimitiveString::create(vm, value.typeof()));
  1157. return {};
  1158. }
  1159. ThrowCompletionOr<void> ToNumeric::execute_impl(Bytecode::Interpreter& interpreter) const
  1160. {
  1161. interpreter.accumulator() = TRY(interpreter.accumulator().to_numeric(interpreter.vm()));
  1162. return {};
  1163. }
  1164. ThrowCompletionOr<void> BlockDeclarationInstantiation::execute_impl(Bytecode::Interpreter& interpreter) const
  1165. {
  1166. auto& vm = interpreter.vm();
  1167. auto old_environment = vm.running_execution_context().lexical_environment;
  1168. interpreter.saved_lexical_environment_stack().append(old_environment);
  1169. vm.running_execution_context().lexical_environment = new_declarative_environment(*old_environment);
  1170. m_scope_node.block_declaration_instantiation(vm, vm.running_execution_context().lexical_environment);
  1171. return {};
  1172. }
  1173. DeprecatedString Load::to_deprecated_string_impl(Bytecode::Executable const&) const
  1174. {
  1175. return DeprecatedString::formatted("Load {}", m_src);
  1176. }
  1177. DeprecatedString LoadImmediate::to_deprecated_string_impl(Bytecode::Executable const&) const
  1178. {
  1179. return DeprecatedString::formatted("LoadImmediate {}", m_value);
  1180. }
  1181. DeprecatedString Store::to_deprecated_string_impl(Bytecode::Executable const&) const
  1182. {
  1183. return DeprecatedString::formatted("Store {}", m_dst);
  1184. }
  1185. DeprecatedString NewBigInt::to_deprecated_string_impl(Bytecode::Executable const&) const
  1186. {
  1187. return DeprecatedString::formatted("NewBigInt \"{}\"", m_bigint.to_base_deprecated(10));
  1188. }
  1189. DeprecatedString NewArray::to_deprecated_string_impl(Bytecode::Executable const&) const
  1190. {
  1191. StringBuilder builder;
  1192. builder.append("NewArray"sv);
  1193. if (m_element_count != 0) {
  1194. builder.appendff(" [{}-{}]", m_elements[0], m_elements[1]);
  1195. }
  1196. return builder.to_deprecated_string();
  1197. }
  1198. DeprecatedString Append::to_deprecated_string_impl(Bytecode::Executable const&) const
  1199. {
  1200. if (m_is_spread)
  1201. return DeprecatedString::formatted("Append lhs: **{}", m_lhs);
  1202. return DeprecatedString::formatted("Append lhs: {}", m_lhs);
  1203. }
  1204. DeprecatedString IteratorToArray::to_deprecated_string_impl(Bytecode::Executable const&) const
  1205. {
  1206. return "IteratorToArray";
  1207. }
  1208. DeprecatedString NewString::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1209. {
  1210. return DeprecatedString::formatted("NewString {} (\"{}\")", m_string, executable.string_table->get(m_string));
  1211. }
  1212. DeprecatedString NewObject::to_deprecated_string_impl(Bytecode::Executable const&) const
  1213. {
  1214. return "NewObject";
  1215. }
  1216. DeprecatedString NewRegExp::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1217. {
  1218. return DeprecatedString::formatted("NewRegExp source:{} (\"{}\") flags:{} (\"{}\")", m_source_index, executable.get_string(m_source_index), m_flags_index, executable.get_string(m_flags_index));
  1219. }
  1220. DeprecatedString CopyObjectExcludingProperties::to_deprecated_string_impl(Bytecode::Executable const&) const
  1221. {
  1222. StringBuilder builder;
  1223. builder.appendff("CopyObjectExcludingProperties from:{}", m_from_object);
  1224. if (m_excluded_names_count != 0) {
  1225. builder.append(" excluding:["sv);
  1226. builder.join(", "sv, ReadonlySpan<Register>(m_excluded_names, m_excluded_names_count));
  1227. builder.append(']');
  1228. }
  1229. return builder.to_deprecated_string();
  1230. }
  1231. DeprecatedString ConcatString::to_deprecated_string_impl(Bytecode::Executable const&) const
  1232. {
  1233. return DeprecatedString::formatted("ConcatString {}", m_lhs);
  1234. }
  1235. DeprecatedString GetVariable::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1236. {
  1237. return DeprecatedString::formatted("GetVariable {} ({})", m_identifier, executable.identifier_table->get(m_identifier));
  1238. }
  1239. DeprecatedString GetLocal::to_deprecated_string_impl(Bytecode::Executable const&) const
  1240. {
  1241. return DeprecatedString::formatted("GetLocal {}", m_index);
  1242. }
  1243. DeprecatedString DeleteVariable::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1244. {
  1245. return DeprecatedString::formatted("DeleteVariable {} ({})", m_identifier, executable.identifier_table->get(m_identifier));
  1246. }
  1247. DeprecatedString CreateLexicalEnvironment::to_deprecated_string_impl(Bytecode::Executable const&) const
  1248. {
  1249. return "CreateLexicalEnvironment"sv;
  1250. }
  1251. DeprecatedString CreateVariable::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1252. {
  1253. auto mode_string = m_mode == EnvironmentMode::Lexical ? "Lexical" : "Variable";
  1254. return DeprecatedString::formatted("CreateVariable env:{} immutable:{} global:{} {} ({})", mode_string, m_is_immutable, m_is_global, m_identifier, executable.identifier_table->get(m_identifier));
  1255. }
  1256. DeprecatedString EnterObjectEnvironment::to_deprecated_string_impl(Executable const&) const
  1257. {
  1258. return DeprecatedString::formatted("EnterObjectEnvironment");
  1259. }
  1260. DeprecatedString SetVariable::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1261. {
  1262. auto initialization_mode_name = m_initialization_mode == InitializationMode ::Initialize ? "Initialize"
  1263. : m_initialization_mode == InitializationMode::Set ? "Set"
  1264. : "InitializeOrSet";
  1265. auto mode_string = m_mode == EnvironmentMode::Lexical ? "Lexical" : "Variable";
  1266. return DeprecatedString::formatted("SetVariable env:{} init:{} {} ({})", mode_string, initialization_mode_name, m_identifier, executable.identifier_table->get(m_identifier));
  1267. }
  1268. DeprecatedString SetLocal::to_deprecated_string_impl(Bytecode::Executable const&) const
  1269. {
  1270. return DeprecatedString::formatted("SetLocal {}", m_index);
  1271. }
  1272. DeprecatedString PutById::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1273. {
  1274. auto kind = m_kind == PropertyKind::Getter
  1275. ? "getter"
  1276. : m_kind == PropertyKind::Setter
  1277. ? "setter"
  1278. : "property";
  1279. return DeprecatedString::formatted("PutById kind:{} base:{}, property:{} ({})", kind, m_base, m_property, executable.identifier_table->get(m_property));
  1280. }
  1281. DeprecatedString PutByIdWithThis::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1282. {
  1283. auto kind = m_kind == PropertyKind::Getter
  1284. ? "getter"
  1285. : m_kind == PropertyKind::Setter
  1286. ? "setter"
  1287. : "property";
  1288. return DeprecatedString::formatted("PutByIdWithThis kind:{} base:{}, property:{} ({}) this_value:{}", kind, m_base, m_property, executable.identifier_table->get(m_property), m_this_value);
  1289. }
  1290. DeprecatedString PutPrivateById::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1291. {
  1292. auto kind = m_kind == PropertyKind::Getter
  1293. ? "getter"
  1294. : m_kind == PropertyKind::Setter
  1295. ? "setter"
  1296. : "property";
  1297. return DeprecatedString::formatted("PutPrivateById kind:{} base:{}, property:{} ({})", kind, m_base, m_property, executable.identifier_table->get(m_property));
  1298. }
  1299. DeprecatedString GetById::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1300. {
  1301. return DeprecatedString::formatted("GetById {} ({})", m_property, executable.identifier_table->get(m_property));
  1302. }
  1303. DeprecatedString GetByIdWithThis::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1304. {
  1305. return DeprecatedString::formatted("GetByIdWithThis {} ({}) this_value:{}", m_property, executable.identifier_table->get(m_property), m_this_value);
  1306. }
  1307. DeprecatedString GetPrivateById::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1308. {
  1309. return DeprecatedString::formatted("GetPrivateById {} ({})", m_property, executable.identifier_table->get(m_property));
  1310. }
  1311. DeprecatedString HasPrivateId::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1312. {
  1313. return DeprecatedString::formatted("HasPrivateId {} ({})", m_property, executable.identifier_table->get(m_property));
  1314. }
  1315. DeprecatedString DeleteById::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1316. {
  1317. return DeprecatedString::formatted("DeleteById {} ({})", m_property, executable.identifier_table->get(m_property));
  1318. }
  1319. DeprecatedString DeleteByIdWithThis::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1320. {
  1321. return DeprecatedString::formatted("DeleteByIdWithThis {} ({}) this_value:{}", m_property, executable.identifier_table->get(m_property), m_this_value);
  1322. }
  1323. DeprecatedString Jump::to_deprecated_string_impl(Bytecode::Executable const&) const
  1324. {
  1325. if (m_true_target.has_value())
  1326. return DeprecatedString::formatted("Jump {}", *m_true_target);
  1327. return DeprecatedString::formatted("Jump <empty>");
  1328. }
  1329. DeprecatedString JumpConditional::to_deprecated_string_impl(Bytecode::Executable const&) const
  1330. {
  1331. auto true_string = m_true_target.has_value() ? DeprecatedString::formatted("{}", *m_true_target) : "<empty>";
  1332. auto false_string = m_false_target.has_value() ? DeprecatedString::formatted("{}", *m_false_target) : "<empty>";
  1333. return DeprecatedString::formatted("JumpConditional true:{} false:{}", true_string, false_string);
  1334. }
  1335. DeprecatedString JumpNullish::to_deprecated_string_impl(Bytecode::Executable const&) const
  1336. {
  1337. auto true_string = m_true_target.has_value() ? DeprecatedString::formatted("{}", *m_true_target) : "<empty>";
  1338. auto false_string = m_false_target.has_value() ? DeprecatedString::formatted("{}", *m_false_target) : "<empty>";
  1339. return DeprecatedString::formatted("JumpNullish null:{} nonnull:{}", true_string, false_string);
  1340. }
  1341. DeprecatedString JumpUndefined::to_deprecated_string_impl(Bytecode::Executable const&) const
  1342. {
  1343. auto true_string = m_true_target.has_value() ? DeprecatedString::formatted("{}", *m_true_target) : "<empty>";
  1344. auto false_string = m_false_target.has_value() ? DeprecatedString::formatted("{}", *m_false_target) : "<empty>";
  1345. return DeprecatedString::formatted("JumpUndefined undefined:{} not undefined:{}", true_string, false_string);
  1346. }
  1347. static StringView call_type_to_string(CallType type)
  1348. {
  1349. switch (type) {
  1350. case CallType::Call:
  1351. return ""sv;
  1352. case CallType::Construct:
  1353. return " (Construct)"sv;
  1354. case CallType::DirectEval:
  1355. return " (DirectEval)"sv;
  1356. }
  1357. VERIFY_NOT_REACHED();
  1358. }
  1359. DeprecatedString Call::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1360. {
  1361. auto type = call_type_to_string(m_type);
  1362. if (m_expression_string.has_value())
  1363. return DeprecatedString::formatted("Call{} callee:{}, this:{}, first_arg:{} ({})", type, m_callee, m_this_value, m_first_argument, executable.get_string(m_expression_string.value()));
  1364. return DeprecatedString::formatted("Call{} callee:{}, this:{}, first_arg:{}", type, m_callee, m_first_argument, m_this_value);
  1365. }
  1366. DeprecatedString CallWithArgumentArray::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1367. {
  1368. auto type = call_type_to_string(m_type);
  1369. if (m_expression_string.has_value())
  1370. return DeprecatedString::formatted("CallWithArgumentArray{} callee:{}, this:{}, arguments:[...acc] ({})", type, m_callee, m_this_value, executable.get_string(m_expression_string.value()));
  1371. return DeprecatedString::formatted("CallWithArgumentArray{} callee:{}, this:{}, arguments:[...acc]", type, m_callee, m_this_value);
  1372. }
  1373. DeprecatedString SuperCallWithArgumentArray::to_deprecated_string_impl(Bytecode::Executable const&) const
  1374. {
  1375. return "SuperCallWithArgumentArray arguments:[...acc]"sv;
  1376. }
  1377. DeprecatedString NewFunction::to_deprecated_string_impl(Bytecode::Executable const&) const
  1378. {
  1379. StringBuilder builder;
  1380. builder.append("NewFunction"sv);
  1381. if (m_function_node.has_name())
  1382. builder.appendff(" name:{}"sv, m_function_node.name());
  1383. if (m_lhs_name.has_value())
  1384. builder.appendff(" lhs_name:{}"sv, m_lhs_name.value());
  1385. if (m_home_object.has_value())
  1386. builder.appendff(" home_object:{}"sv, m_home_object.value());
  1387. return builder.to_deprecated_string();
  1388. }
  1389. DeprecatedString NewClass::to_deprecated_string_impl(Bytecode::Executable const&) const
  1390. {
  1391. StringBuilder builder;
  1392. auto name = m_class_expression.name();
  1393. builder.appendff("NewClass '{}'"sv, name.is_null() ? ""sv : name);
  1394. if (m_lhs_name.has_value())
  1395. builder.appendff(" lhs_name:{}"sv, m_lhs_name.value());
  1396. return builder.to_deprecated_string();
  1397. }
  1398. DeprecatedString Return::to_deprecated_string_impl(Bytecode::Executable const&) const
  1399. {
  1400. return "Return";
  1401. }
  1402. DeprecatedString Increment::to_deprecated_string_impl(Bytecode::Executable const&) const
  1403. {
  1404. return "Increment";
  1405. }
  1406. DeprecatedString Decrement::to_deprecated_string_impl(Bytecode::Executable const&) const
  1407. {
  1408. return "Decrement";
  1409. }
  1410. DeprecatedString Throw::to_deprecated_string_impl(Bytecode::Executable const&) const
  1411. {
  1412. return "Throw";
  1413. }
  1414. DeprecatedString ThrowIfNotObject::to_deprecated_string_impl(Bytecode::Executable const&) const
  1415. {
  1416. return "ThrowIfNotObject";
  1417. }
  1418. DeprecatedString ThrowIfNullish::to_deprecated_string_impl(Bytecode::Executable const&) const
  1419. {
  1420. return "ThrowIfNullish";
  1421. }
  1422. DeprecatedString EnterUnwindContext::to_deprecated_string_impl(Bytecode::Executable const&) const
  1423. {
  1424. auto handler_string = m_handler_target.has_value() ? DeprecatedString::formatted("{}", *m_handler_target) : "<empty>";
  1425. auto finalizer_string = m_finalizer_target.has_value() ? DeprecatedString::formatted("{}", *m_finalizer_target) : "<empty>";
  1426. return DeprecatedString::formatted("EnterUnwindContext handler:{} finalizer:{} entry:{}", handler_string, finalizer_string, m_entry_point);
  1427. }
  1428. DeprecatedString ScheduleJump::to_deprecated_string_impl(Bytecode::Executable const&) const
  1429. {
  1430. return DeprecatedString::formatted("ScheduleJump {}", m_target);
  1431. }
  1432. DeprecatedString LeaveLexicalEnvironment::to_deprecated_string_impl(Bytecode::Executable const&) const
  1433. {
  1434. return "LeaveLexicalEnvironment"sv;
  1435. }
  1436. DeprecatedString LeaveUnwindContext::to_deprecated_string_impl(Bytecode::Executable const&) const
  1437. {
  1438. return "LeaveUnwindContext";
  1439. }
  1440. DeprecatedString ContinuePendingUnwind::to_deprecated_string_impl(Bytecode::Executable const&) const
  1441. {
  1442. return DeprecatedString::formatted("ContinuePendingUnwind resume:{}", m_resume_target);
  1443. }
  1444. DeprecatedString PushDeclarativeEnvironment::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1445. {
  1446. StringBuilder builder;
  1447. builder.append("PushDeclarativeEnvironment"sv);
  1448. if (!m_variables.is_empty()) {
  1449. builder.append(" {"sv);
  1450. Vector<DeprecatedString> names;
  1451. for (auto& it : m_variables)
  1452. names.append(executable.get_string(it.key));
  1453. builder.append('}');
  1454. builder.join(", "sv, names);
  1455. }
  1456. return builder.to_deprecated_string();
  1457. }
  1458. DeprecatedString Yield::to_deprecated_string_impl(Bytecode::Executable const&) const
  1459. {
  1460. if (m_continuation_label.has_value())
  1461. return DeprecatedString::formatted("Yield continuation:@{}", m_continuation_label->block().name());
  1462. return DeprecatedString::formatted("Yield return");
  1463. }
  1464. DeprecatedString GetByValue::to_deprecated_string_impl(Bytecode::Executable const&) const
  1465. {
  1466. return DeprecatedString::formatted("GetByValue base:{}", m_base);
  1467. }
  1468. DeprecatedString GetByValueWithThis::to_deprecated_string_impl(Bytecode::Executable const&) const
  1469. {
  1470. return DeprecatedString::formatted("GetByValueWithThis base:{} this_value:{}", m_base, m_this_value);
  1471. }
  1472. DeprecatedString PutByValue::to_deprecated_string_impl(Bytecode::Executable const&) const
  1473. {
  1474. auto kind = m_kind == PropertyKind::Getter
  1475. ? "getter"
  1476. : m_kind == PropertyKind::Setter
  1477. ? "setter"
  1478. : "property";
  1479. return DeprecatedString::formatted("PutByValue kind:{} base:{}, property:{}", kind, m_base, m_property);
  1480. }
  1481. DeprecatedString PutByValueWithThis::to_deprecated_string_impl(Bytecode::Executable const&) const
  1482. {
  1483. auto kind = m_kind == PropertyKind::Getter
  1484. ? "getter"
  1485. : m_kind == PropertyKind::Setter
  1486. ? "setter"
  1487. : "property";
  1488. return DeprecatedString::formatted("PutByValueWithThis kind:{} base:{}, property:{} this_value:{}", kind, m_base, m_property, m_this_value);
  1489. }
  1490. DeprecatedString DeleteByValue::to_deprecated_string_impl(Bytecode::Executable const&) const
  1491. {
  1492. return DeprecatedString::formatted("DeleteByValue base:{}", m_base);
  1493. }
  1494. DeprecatedString DeleteByValueWithThis::to_deprecated_string_impl(Bytecode::Executable const&) const
  1495. {
  1496. return DeprecatedString::formatted("DeleteByValueWithThis base:{} this_value:{}", m_base, m_this_value);
  1497. }
  1498. DeprecatedString GetIterator::to_deprecated_string_impl(Executable const&) const
  1499. {
  1500. auto hint = m_hint == IteratorHint::Sync ? "sync" : "async";
  1501. return DeprecatedString::formatted("GetIterator hint:{}", hint);
  1502. }
  1503. DeprecatedString GetMethod::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1504. {
  1505. return DeprecatedString::formatted("GetMethod {} ({})", m_property, executable.identifier_table->get(m_property));
  1506. }
  1507. DeprecatedString GetObjectPropertyIterator::to_deprecated_string_impl(Bytecode::Executable const&) const
  1508. {
  1509. return "GetObjectPropertyIterator";
  1510. }
  1511. DeprecatedString IteratorClose::to_deprecated_string_impl(Bytecode::Executable const&) const
  1512. {
  1513. if (!m_completion_value.has_value())
  1514. return DeprecatedString::formatted("IteratorClose completion_type={} completion_value=<empty>", to_underlying(m_completion_type));
  1515. auto completion_value_string = m_completion_value->to_string_without_side_effects().release_value_but_fixme_should_propagate_errors();
  1516. return DeprecatedString::formatted("IteratorClose completion_type={} completion_value={}", to_underlying(m_completion_type), completion_value_string);
  1517. }
  1518. DeprecatedString IteratorNext::to_deprecated_string_impl(Executable const&) const
  1519. {
  1520. return "IteratorNext";
  1521. }
  1522. DeprecatedString IteratorResultDone::to_deprecated_string_impl(Executable const&) const
  1523. {
  1524. return "IteratorResultDone";
  1525. }
  1526. DeprecatedString IteratorResultValue::to_deprecated_string_impl(Executable const&) const
  1527. {
  1528. return "IteratorResultValue";
  1529. }
  1530. DeprecatedString ResolveThisBinding::to_deprecated_string_impl(Bytecode::Executable const&) const
  1531. {
  1532. return "ResolveThisBinding"sv;
  1533. }
  1534. DeprecatedString ResolveSuperBase::to_deprecated_string_impl(Bytecode::Executable const&) const
  1535. {
  1536. return "ResolveSuperBase"sv;
  1537. }
  1538. DeprecatedString GetNewTarget::to_deprecated_string_impl(Bytecode::Executable const&) const
  1539. {
  1540. return "GetNewTarget"sv;
  1541. }
  1542. DeprecatedString TypeofVariable::to_deprecated_string_impl(Bytecode::Executable const& executable) const
  1543. {
  1544. return DeprecatedString::formatted("TypeofVariable {} ({})", m_identifier, executable.identifier_table->get(m_identifier));
  1545. }
  1546. DeprecatedString TypeofLocal::to_deprecated_string_impl(Bytecode::Executable const&) const
  1547. {
  1548. return DeprecatedString::formatted("TypeofLocal {}", m_index);
  1549. }
  1550. DeprecatedString ToNumeric::to_deprecated_string_impl(Bytecode::Executable const&) const
  1551. {
  1552. return "ToNumeric"sv;
  1553. }
  1554. DeprecatedString BlockDeclarationInstantiation::to_deprecated_string_impl(Bytecode::Executable const&) const
  1555. {
  1556. return "BlockDeclarationInstantiation"sv;
  1557. }
  1558. DeprecatedString ImportCall::to_deprecated_string_impl(Bytecode::Executable const&) const
  1559. {
  1560. return DeprecatedString::formatted("ImportCall specifier:{} options:{}"sv, m_specifier, m_options);
  1561. }
  1562. }