ASTCodegen.cpp 164 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490
  1. /*
  2. * Copyright (c) 2021-2024, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2021, Linus Groh <linusg@serenityos.org>
  4. * Copyright (c) 2021, Gunnar Beutner <gbeutner@serenityos.org>
  5. * Copyright (c) 2021, Marcin Gasperowicz <xnooga@gmail.com>
  6. *
  7. * SPDX-License-Identifier: BSD-2-Clause
  8. */
  9. #include <AK/Find.h>
  10. #include <AK/Queue.h>
  11. #include <LibJS/AST.h>
  12. #include <LibJS/Bytecode/Generator.h>
  13. #include <LibJS/Bytecode/Instruction.h>
  14. #include <LibJS/Bytecode/Op.h>
  15. #include <LibJS/Bytecode/Register.h>
  16. #include <LibJS/Bytecode/StringTable.h>
  17. #include <LibJS/Runtime/Environment.h>
  18. #include <LibJS/Runtime/ErrorTypes.h>
  19. namespace JS {
  20. using namespace JS::Bytecode;
  21. static ScopedOperand choose_dst(Bytecode::Generator& generator, Optional<ScopedOperand> const& preferred_dst)
  22. {
  23. if (preferred_dst.has_value())
  24. return preferred_dst.value();
  25. return generator.allocate_register();
  26. }
  27. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ASTNode::generate_bytecode(Bytecode::Generator&, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  28. {
  29. return Bytecode::CodeGenerationError {
  30. this,
  31. "Missing generate_bytecode()"sv,
  32. };
  33. }
  34. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ScopeNode::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  35. {
  36. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  37. bool did_create_lexical_environment = false;
  38. if (is<BlockStatement>(*this)) {
  39. if (has_lexical_declarations()) {
  40. did_create_lexical_environment = generator.emit_block_declaration_instantiation(*this);
  41. }
  42. } else if (is<Program>(*this)) {
  43. // GlobalDeclarationInstantiation is handled by the C++ AO.
  44. } else {
  45. // FunctionDeclarationInstantiation is handled by the C++ AO.
  46. }
  47. Optional<ScopedOperand> last_result;
  48. for (auto& child : children()) {
  49. auto result = TRY(child->generate_bytecode(generator));
  50. if (result.has_value())
  51. last_result = result;
  52. if (generator.is_current_block_terminated())
  53. break;
  54. }
  55. if (did_create_lexical_environment)
  56. generator.end_variable_scope();
  57. return last_result;
  58. }
  59. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> EmptyStatement::generate_bytecode(Bytecode::Generator&, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  60. {
  61. return Optional<ScopedOperand> {};
  62. }
  63. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ExpressionStatement::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  64. {
  65. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  66. return m_expression->generate_bytecode(generator);
  67. }
  68. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> BinaryExpression::generate_bytecode(Bytecode::Generator& generator, Optional<ScopedOperand> preferred_dst) const
  69. {
  70. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  71. if (m_op == BinaryOp::In && is<PrivateIdentifier>(*m_lhs)) {
  72. auto const& private_identifier = static_cast<PrivateIdentifier const&>(*m_lhs).string();
  73. auto base = TRY(m_rhs->generate_bytecode(generator)).value();
  74. auto dst = choose_dst(generator, preferred_dst);
  75. generator.emit<Bytecode::Op::HasPrivateId>(dst, base, generator.intern_identifier(private_identifier));
  76. return dst;
  77. }
  78. // OPTIMIZATION: If LHS and/or RHS are numeric literals, we make sure they are converted to i32/u32
  79. // as appropriate, to avoid having to perform these conversions at runtime.
  80. auto get_left_side = [&](Expression const& side) -> CodeGenerationErrorOr<Optional<ScopedOperand>> {
  81. switch (m_op) {
  82. case BinaryOp::BitwiseAnd:
  83. case BinaryOp::BitwiseOr:
  84. case BinaryOp::BitwiseXor:
  85. case BinaryOp::LeftShift:
  86. case BinaryOp::RightShift:
  87. case BinaryOp::UnsignedRightShift:
  88. // LHS will always be converted to i32 for these ops.
  89. if (side.is_numeric_literal()) {
  90. auto value = MUST(static_cast<NumericLiteral const&>(side).value().to_i32(generator.vm()));
  91. return generator.add_constant(Value(value));
  92. }
  93. break;
  94. default:
  95. break;
  96. }
  97. return side.generate_bytecode(generator);
  98. };
  99. auto get_right_side = [&](Expression const& side) -> CodeGenerationErrorOr<Optional<ScopedOperand>> {
  100. switch (m_op) {
  101. case BinaryOp::BitwiseAnd:
  102. case BinaryOp::BitwiseOr:
  103. case BinaryOp::BitwiseXor:
  104. // RHS will always be converted to i32 for these ops.
  105. if (side.is_numeric_literal()) {
  106. auto value = MUST(static_cast<NumericLiteral const&>(side).value().to_i32(generator.vm()));
  107. return generator.add_constant(Value(value));
  108. }
  109. break;
  110. case BinaryOp::LeftShift:
  111. case BinaryOp::RightShift:
  112. case BinaryOp::UnsignedRightShift:
  113. // RHS will always be converted to u32 for these ops.
  114. if (side.is_numeric_literal()) {
  115. auto value = MUST(static_cast<NumericLiteral const&>(side).value().to_u32(generator.vm()));
  116. return generator.add_constant(Value(value));
  117. }
  118. break;
  119. default:
  120. break;
  121. }
  122. return side.generate_bytecode(generator);
  123. };
  124. auto lhs = TRY(get_left_side(*m_lhs)).value();
  125. auto rhs = TRY(get_right_side(*m_rhs)).value();
  126. auto dst = choose_dst(generator, preferred_dst);
  127. switch (m_op) {
  128. case BinaryOp::Addition:
  129. generator.emit<Bytecode::Op::Add>(dst, lhs, rhs);
  130. break;
  131. case BinaryOp::Subtraction:
  132. generator.emit<Bytecode::Op::Sub>(dst, lhs, rhs);
  133. break;
  134. case BinaryOp::Multiplication:
  135. generator.emit<Bytecode::Op::Mul>(dst, lhs, rhs);
  136. break;
  137. case BinaryOp::Division:
  138. generator.emit<Bytecode::Op::Div>(dst, lhs, rhs);
  139. break;
  140. case BinaryOp::Modulo:
  141. generator.emit<Bytecode::Op::Mod>(dst, lhs, rhs);
  142. break;
  143. case BinaryOp::Exponentiation:
  144. generator.emit<Bytecode::Op::Exp>(dst, lhs, rhs);
  145. break;
  146. case BinaryOp::GreaterThan:
  147. generator.emit<Bytecode::Op::GreaterThan>(dst, lhs, rhs);
  148. break;
  149. case BinaryOp::GreaterThanEquals:
  150. generator.emit<Bytecode::Op::GreaterThanEquals>(dst, lhs, rhs);
  151. break;
  152. case BinaryOp::LessThan:
  153. generator.emit<Bytecode::Op::LessThan>(dst, lhs, rhs);
  154. break;
  155. case BinaryOp::LessThanEquals:
  156. generator.emit<Bytecode::Op::LessThanEquals>(dst, lhs, rhs);
  157. break;
  158. case BinaryOp::LooselyInequals:
  159. generator.emit<Bytecode::Op::LooselyInequals>(dst, lhs, rhs);
  160. break;
  161. case BinaryOp::LooselyEquals:
  162. generator.emit<Bytecode::Op::LooselyEquals>(dst, lhs, rhs);
  163. break;
  164. case BinaryOp::StrictlyInequals:
  165. generator.emit<Bytecode::Op::StrictlyInequals>(dst, lhs, rhs);
  166. break;
  167. case BinaryOp::StrictlyEquals:
  168. generator.emit<Bytecode::Op::StrictlyEquals>(dst, lhs, rhs);
  169. break;
  170. case BinaryOp::BitwiseAnd:
  171. generator.emit<Bytecode::Op::BitwiseAnd>(dst, lhs, rhs);
  172. break;
  173. case BinaryOp::BitwiseOr:
  174. generator.emit<Bytecode::Op::BitwiseOr>(dst, lhs, rhs);
  175. break;
  176. case BinaryOp::BitwiseXor:
  177. generator.emit<Bytecode::Op::BitwiseXor>(dst, lhs, rhs);
  178. break;
  179. case BinaryOp::LeftShift:
  180. generator.emit<Bytecode::Op::LeftShift>(dst, lhs, rhs);
  181. break;
  182. case BinaryOp::RightShift:
  183. generator.emit<Bytecode::Op::RightShift>(dst, lhs, rhs);
  184. break;
  185. case BinaryOp::UnsignedRightShift:
  186. generator.emit<Bytecode::Op::UnsignedRightShift>(dst, lhs, rhs);
  187. break;
  188. case BinaryOp::In:
  189. generator.emit<Bytecode::Op::In>(dst, lhs, rhs);
  190. break;
  191. case BinaryOp::InstanceOf:
  192. generator.emit<Bytecode::Op::InstanceOf>(dst, lhs, rhs);
  193. break;
  194. default:
  195. VERIFY_NOT_REACHED();
  196. }
  197. return dst;
  198. }
  199. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> LogicalExpression::generate_bytecode(Bytecode::Generator& generator, Optional<ScopedOperand> preferred_dst) const
  200. {
  201. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  202. auto dst = choose_dst(generator, preferred_dst);
  203. auto lhs = TRY(m_lhs->generate_bytecode(generator, preferred_dst)).value();
  204. // FIXME: Only mov lhs into dst in case lhs is the value taken.
  205. generator.emit<Bytecode::Op::Mov>(dst, lhs);
  206. // lhs
  207. // jump op (true) end (false) rhs
  208. // rhs
  209. // jump always (true) end
  210. // end
  211. auto& rhs_block = generator.make_block();
  212. auto& end_block = generator.make_block();
  213. switch (m_op) {
  214. case LogicalOp::And:
  215. generator.emit_jump_if(
  216. lhs,
  217. Bytecode::Label { rhs_block },
  218. Bytecode::Label { end_block });
  219. break;
  220. case LogicalOp::Or:
  221. generator.emit_jump_if(
  222. lhs,
  223. Bytecode::Label { end_block },
  224. Bytecode::Label { rhs_block });
  225. break;
  226. case LogicalOp::NullishCoalescing:
  227. generator.emit<Bytecode::Op::JumpNullish>(
  228. lhs,
  229. Bytecode::Label { rhs_block },
  230. Bytecode::Label { end_block });
  231. break;
  232. default:
  233. VERIFY_NOT_REACHED();
  234. }
  235. generator.switch_to_basic_block(rhs_block);
  236. auto rhs = TRY(m_rhs->generate_bytecode(generator)).value();
  237. generator.emit<Bytecode::Op::Mov>(dst, rhs);
  238. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { end_block });
  239. generator.switch_to_basic_block(end_block);
  240. return dst;
  241. }
  242. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> UnaryExpression::generate_bytecode(Bytecode::Generator& generator, Optional<ScopedOperand> preferred_dst) const
  243. {
  244. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  245. // OPTIMIZATION: Turn expressions like `-1` into a constant.
  246. if (m_op == UnaryOp::Minus && is<NumericLiteral>(*m_lhs)) {
  247. auto& numeric_literal = static_cast<NumericLiteral const&>(*m_lhs);
  248. auto value = numeric_literal.value();
  249. return generator.add_constant(Value(-value.as_double()));
  250. }
  251. if (m_op == UnaryOp::Delete)
  252. return generator.emit_delete_reference(m_lhs);
  253. Optional<ScopedOperand> src;
  254. // Typeof needs some special handling for when the LHS is an Identifier. Namely, it shouldn't throw on unresolvable references, but instead return "undefined".
  255. if (m_op != UnaryOp::Typeof)
  256. src = TRY(m_lhs->generate_bytecode(generator)).value();
  257. auto dst = choose_dst(generator, preferred_dst);
  258. switch (m_op) {
  259. case UnaryOp::BitwiseNot:
  260. generator.emit<Bytecode::Op::BitwiseNot>(dst, *src);
  261. break;
  262. case UnaryOp::Not:
  263. generator.emit<Bytecode::Op::Not>(dst, *src);
  264. break;
  265. case UnaryOp::Plus:
  266. generator.emit<Bytecode::Op::UnaryPlus>(dst, *src);
  267. break;
  268. case UnaryOp::Minus:
  269. generator.emit<Bytecode::Op::UnaryMinus>(dst, *src);
  270. break;
  271. case UnaryOp::Typeof:
  272. if (is<Identifier>(*m_lhs)) {
  273. auto& identifier = static_cast<Identifier const&>(*m_lhs);
  274. if (!identifier.is_local()) {
  275. generator.emit<Bytecode::Op::TypeofVariable>(dst, generator.intern_identifier(identifier.string()));
  276. break;
  277. }
  278. }
  279. src = TRY(m_lhs->generate_bytecode(generator)).value();
  280. generator.emit<Bytecode::Op::Typeof>(dst, *src);
  281. break;
  282. case UnaryOp::Void:
  283. return generator.add_constant(js_undefined());
  284. case UnaryOp::Delete: // Delete is implemented above.
  285. default:
  286. VERIFY_NOT_REACHED();
  287. }
  288. return dst;
  289. }
  290. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> NumericLiteral::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  291. {
  292. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  293. return generator.add_constant(Value(m_value), Bytecode::Generator::DeduplicateConstant::No);
  294. }
  295. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> BooleanLiteral::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  296. {
  297. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  298. return generator.add_constant(Value(m_value));
  299. }
  300. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> NullLiteral::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  301. {
  302. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  303. return generator.add_constant(js_null());
  304. }
  305. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> BigIntLiteral::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  306. {
  307. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  308. // 1. Return the NumericValue of NumericLiteral as defined in 12.8.3.
  309. auto integer = [&] {
  310. if (m_value[0] == '0' && m_value.length() >= 3)
  311. if (m_value[1] == 'x' || m_value[1] == 'X')
  312. return MUST(Crypto::SignedBigInteger::from_base(16, m_value.substring(2, m_value.length() - 3)));
  313. if (m_value[1] == 'o' || m_value[1] == 'O')
  314. return MUST(Crypto::SignedBigInteger::from_base(8, m_value.substring(2, m_value.length() - 3)));
  315. if (m_value[1] == 'b' || m_value[1] == 'B')
  316. return MUST(Crypto::SignedBigInteger::from_base(2, m_value.substring(2, m_value.length() - 3)));
  317. return MUST(Crypto::SignedBigInteger::from_base(10, m_value.substring(0, m_value.length() - 1)));
  318. }();
  319. return generator.add_constant(BigInt::create(generator.vm(), move(integer)), Bytecode::Generator::DeduplicateConstant::No);
  320. }
  321. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> StringLiteral::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  322. {
  323. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  324. return generator.add_constant(PrimitiveString::create(generator.vm(), m_value), Bytecode::Generator::DeduplicateConstant::No);
  325. }
  326. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> RegExpLiteral::generate_bytecode(Bytecode::Generator& generator, Optional<ScopedOperand> preferred_dst) const
  327. {
  328. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  329. auto source_index = generator.intern_string(m_pattern);
  330. auto flags_index = generator.intern_string(m_flags);
  331. auto regex_index = generator.intern_regex(Bytecode::ParsedRegex {
  332. .regex = m_parsed_regex,
  333. .pattern = m_parsed_pattern,
  334. .flags = m_parsed_flags,
  335. });
  336. auto dst = choose_dst(generator, preferred_dst);
  337. generator.emit<Bytecode::Op::NewRegExp>(dst, source_index, flags_index, regex_index);
  338. return dst;
  339. }
  340. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> Identifier::generate_bytecode(Bytecode::Generator& generator, Optional<ScopedOperand> preferred_dst) const
  341. {
  342. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  343. if (is_local()) {
  344. auto local = generator.local(local_variable_index());
  345. if (!generator.is_local_initialized(local_variable_index())) {
  346. generator.emit<Bytecode::Op::ThrowIfTDZ>(local);
  347. }
  348. return local;
  349. }
  350. if (is_global() && m_string == "undefined"sv) {
  351. return generator.add_constant(js_undefined());
  352. }
  353. auto dst = choose_dst(generator, preferred_dst);
  354. if (is_global()) {
  355. generator.emit<Bytecode::Op::GetGlobal>(dst, generator.intern_identifier(m_string), generator.next_global_variable_cache());
  356. } else {
  357. generator.emit<Bytecode::Op::GetBinding>(dst, generator.intern_identifier(m_string));
  358. }
  359. return dst;
  360. }
  361. static Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> arguments_to_array_for_call(Bytecode::Generator& generator, ReadonlySpan<CallExpression::Argument> arguments)
  362. {
  363. auto dst = generator.allocate_register();
  364. if (arguments.is_empty()) {
  365. generator.emit<Bytecode::Op::NewArray>(dst);
  366. return dst;
  367. }
  368. auto first_spread = find_if(arguments.begin(), arguments.end(), [](auto el) { return el.is_spread; });
  369. Vector<ScopedOperand> args;
  370. args.ensure_capacity(first_spread.index());
  371. for (auto it = arguments.begin(); it != first_spread; ++it) {
  372. VERIFY(!it->is_spread);
  373. auto reg = generator.allocate_register();
  374. auto value = TRY(it->value->generate_bytecode(generator)).value();
  375. generator.emit<Bytecode::Op::Mov>(reg, value);
  376. args.append(move(reg));
  377. }
  378. if (first_spread.index() != 0)
  379. generator.emit_with_extra_operand_slots<Bytecode::Op::NewArray>(args.size(), dst, args);
  380. else
  381. generator.emit<Bytecode::Op::NewArray>(dst);
  382. if (first_spread != arguments.end()) {
  383. for (auto it = first_spread; it != arguments.end(); ++it) {
  384. auto value = TRY(it->value->generate_bytecode(generator)).value();
  385. generator.emit<Bytecode::Op::ArrayAppend>(dst, value, it->is_spread);
  386. }
  387. }
  388. return dst;
  389. }
  390. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> SuperCall::generate_bytecode(Bytecode::Generator& generator, Optional<ScopedOperand> preferred_dst) const
  391. {
  392. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  393. Optional<ScopedOperand> arguments;
  394. if (m_is_synthetic == IsPartOfSyntheticConstructor::Yes) {
  395. // NOTE: This is the case where we have a fake constructor(...args) { super(...args); } which
  396. // shouldn't call @@iterator of %Array.prototype%.
  397. VERIFY(m_arguments.size() == 1);
  398. VERIFY(m_arguments[0].is_spread);
  399. auto const& argument = m_arguments[0];
  400. // This generates a single argument.
  401. arguments = MUST(argument.value->generate_bytecode(generator));
  402. } else {
  403. arguments = TRY(arguments_to_array_for_call(generator, m_arguments)).value();
  404. }
  405. auto dst = choose_dst(generator, preferred_dst);
  406. generator.emit<Bytecode::Op::SuperCallWithArgumentArray>(dst, *arguments, m_is_synthetic == IsPartOfSyntheticConstructor::Yes);
  407. return dst;
  408. }
  409. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> AssignmentExpression::generate_bytecode(Bytecode::Generator& generator, Optional<ScopedOperand> preferred_dst) const
  410. {
  411. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  412. if (m_op == AssignmentOp::Assignment) {
  413. // AssignmentExpression : LeftHandSideExpression = AssignmentExpression
  414. return m_lhs.visit(
  415. // 1. If LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral, then
  416. [&](NonnullRefPtr<Expression const> const& lhs) -> Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> {
  417. // a. Let lref be the result of evaluating LeftHandSideExpression.
  418. // b. ReturnIfAbrupt(lref).
  419. Optional<ScopedOperand> base;
  420. Optional<ScopedOperand> computed_property;
  421. Optional<ScopedOperand> this_value;
  422. bool lhs_is_super_expression = false;
  423. if (is<MemberExpression>(*lhs)) {
  424. auto& expression = static_cast<MemberExpression const&>(*lhs);
  425. lhs_is_super_expression = is<SuperExpression>(expression.object());
  426. if (!lhs_is_super_expression) {
  427. base = TRY(expression.object().generate_bytecode(generator)).value();
  428. } else {
  429. // https://tc39.es/ecma262/#sec-super-keyword-runtime-semantics-evaluation
  430. // 1. Let env be GetThisEnvironment().
  431. // 2. Let actualThis be ? env.GetThisBinding().
  432. this_value = generator.get_this();
  433. // SuperProperty : super [ Expression ]
  434. // 3. Let propertyNameReference be ? Evaluation of Expression.
  435. // 4. Let propertyNameValue be ? GetValue(propertyNameReference).
  436. }
  437. if (expression.is_computed()) {
  438. auto property = TRY(expression.property().generate_bytecode(generator)).value();
  439. computed_property = generator.allocate_register();
  440. generator.emit<Bytecode::Op::Mov>(*computed_property, property);
  441. // To be continued later with PutByValue.
  442. } else if (expression.property().is_identifier()) {
  443. // Do nothing, this will be handled by PutById later.
  444. } else if (expression.property().is_private_identifier()) {
  445. // Do nothing, this will be handled by PutPrivateById later.
  446. } else {
  447. return Bytecode::CodeGenerationError {
  448. &expression,
  449. "Unimplemented non-computed member expression"sv
  450. };
  451. }
  452. if (lhs_is_super_expression) {
  453. // 5/7. Return ? MakeSuperPropertyReference(actualThis, propertyKey, strict).
  454. // https://tc39.es/ecma262/#sec-makesuperpropertyreference
  455. // 1. Let env be GetThisEnvironment().
  456. // 2. Assert: env.HasSuperBinding() is true.
  457. // 3. Let baseValue be ? env.GetSuperBase().
  458. // 4. Return the Reference Record { [[Base]]: baseValue, [[ReferencedName]]: propertyKey, [[Strict]]: strict, [[ThisValue]]: actualThis }.
  459. base = generator.allocate_register();
  460. generator.emit<Bytecode::Op::ResolveSuperBase>(*base);
  461. }
  462. } else if (is<Identifier>(*lhs)) {
  463. // NOTE: For Identifiers, we cannot perform GetBinding and then write into the reference it retrieves, only SetVariable can do this.
  464. // FIXME: However, this breaks spec as we are doing variable lookup after evaluating the RHS. This is observable in an object environment, where we visibly perform HasOwnProperty and Get(@@unscopables) on the binded object.
  465. } else {
  466. (void)TRY(lhs->generate_bytecode(generator));
  467. }
  468. // FIXME: c. If IsAnonymousFunctionDefinition(AssignmentExpression) and IsIdentifierRef of LeftHandSideExpression are both true, then
  469. // i. Let rval be ? NamedEvaluation of AssignmentExpression with argument lref.[[ReferencedName]].
  470. // d. Else,
  471. // i. Let rref be the result of evaluating AssignmentExpression.
  472. // ii. Let rval be ? GetValue(rref).
  473. auto rval = TRY([&]() -> Bytecode::CodeGenerationErrorOr<ScopedOperand> {
  474. if (lhs->is_identifier()) {
  475. return TRY(generator.emit_named_evaluation_if_anonymous_function(*m_rhs, generator.intern_identifier(static_cast<Identifier const&>(*lhs).string()))).value();
  476. } else {
  477. return TRY(m_rhs->generate_bytecode(generator)).value();
  478. }
  479. }());
  480. // e. Perform ? PutValue(lref, rval).
  481. if (is<Identifier>(*lhs)) {
  482. auto& identifier = static_cast<Identifier const&>(*lhs);
  483. generator.emit_set_variable(identifier, rval);
  484. } else if (is<MemberExpression>(*lhs)) {
  485. auto& expression = static_cast<MemberExpression const&>(*lhs);
  486. auto base_identifier = generator.intern_identifier_for_expression(expression.object());
  487. if (expression.is_computed()) {
  488. if (!lhs_is_super_expression)
  489. generator.emit<Bytecode::Op::PutByValue>(*base, *computed_property, rval, Bytecode::Op::PropertyKind::KeyValue, move(base_identifier));
  490. else
  491. generator.emit<Bytecode::Op::PutByValueWithThis>(*base, *computed_property, *this_value, rval);
  492. } else if (expression.property().is_identifier()) {
  493. auto identifier_table_ref = generator.intern_identifier(verify_cast<Identifier>(expression.property()).string());
  494. if (!lhs_is_super_expression)
  495. generator.emit<Bytecode::Op::PutById>(*base, identifier_table_ref, rval, Bytecode::Op::PropertyKind::KeyValue, generator.next_property_lookup_cache(), move(base_identifier));
  496. else
  497. generator.emit<Bytecode::Op::PutByIdWithThis>(*base, *this_value, identifier_table_ref, rval, Bytecode::Op::PropertyKind::KeyValue, generator.next_property_lookup_cache());
  498. } else if (expression.property().is_private_identifier()) {
  499. auto identifier_table_ref = generator.intern_identifier(verify_cast<PrivateIdentifier>(expression.property()).string());
  500. generator.emit<Bytecode::Op::PutPrivateById>(*base, identifier_table_ref, rval);
  501. } else {
  502. return Bytecode::CodeGenerationError {
  503. &expression,
  504. "Unimplemented non-computed member expression"sv
  505. };
  506. }
  507. } else {
  508. return Bytecode::CodeGenerationError {
  509. lhs,
  510. "Unimplemented/invalid node used a reference"sv
  511. };
  512. }
  513. // f. Return rval.
  514. return rval;
  515. },
  516. // 2. Let assignmentPattern be the AssignmentPattern that is covered by LeftHandSideExpression.
  517. [&](NonnullRefPtr<BindingPattern const> const& pattern) -> Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> {
  518. // 3. Let rref be the result of evaluating AssignmentExpression.
  519. // 4. Let rval be ? GetValue(rref).
  520. auto rval = TRY(m_rhs->generate_bytecode(generator)).value();
  521. // 5. Perform ? DestructuringAssignmentEvaluation of assignmentPattern with argument rval.
  522. TRY(pattern->generate_bytecode(generator, Bytecode::Op::BindingInitializationMode::Set, rval, false));
  523. // 6. Return rval.
  524. return rval;
  525. });
  526. }
  527. VERIFY(m_lhs.has<NonnullRefPtr<Expression const>>());
  528. auto& lhs_expression = m_lhs.get<NonnullRefPtr<Expression const>>();
  529. auto reference_operands = TRY(generator.emit_load_from_reference(lhs_expression));
  530. auto lhs = reference_operands.loaded_value.value();
  531. Bytecode::BasicBlock* rhs_block_ptr { nullptr };
  532. Bytecode::BasicBlock* lhs_block_ptr { nullptr };
  533. Bytecode::BasicBlock* end_block_ptr { nullptr };
  534. // Logical assignments short circuit.
  535. if (m_op == AssignmentOp::AndAssignment) { // &&=
  536. rhs_block_ptr = &generator.make_block();
  537. lhs_block_ptr = &generator.make_block();
  538. end_block_ptr = &generator.make_block();
  539. generator.emit_jump_if(
  540. lhs,
  541. Bytecode::Label { *rhs_block_ptr },
  542. Bytecode::Label { *lhs_block_ptr });
  543. } else if (m_op == AssignmentOp::OrAssignment) { // ||=
  544. rhs_block_ptr = &generator.make_block();
  545. lhs_block_ptr = &generator.make_block();
  546. end_block_ptr = &generator.make_block();
  547. generator.emit_jump_if(
  548. lhs,
  549. Bytecode::Label { *lhs_block_ptr },
  550. Bytecode::Label { *rhs_block_ptr });
  551. } else if (m_op == AssignmentOp::NullishAssignment) { // ??=
  552. rhs_block_ptr = &generator.make_block();
  553. lhs_block_ptr = &generator.make_block();
  554. end_block_ptr = &generator.make_block();
  555. generator.emit<Bytecode::Op::JumpNullish>(
  556. lhs,
  557. Bytecode::Label { *rhs_block_ptr },
  558. Bytecode::Label { *lhs_block_ptr });
  559. }
  560. if (rhs_block_ptr)
  561. generator.switch_to_basic_block(*rhs_block_ptr);
  562. auto rhs = TRY([&]() -> Bytecode::CodeGenerationErrorOr<ScopedOperand> {
  563. if (lhs_expression->is_identifier()) {
  564. return TRY(generator.emit_named_evaluation_if_anonymous_function(*m_rhs, generator.intern_identifier(static_cast<Identifier const&>(*lhs_expression).string()))).value();
  565. }
  566. return TRY(m_rhs->generate_bytecode(generator)).value();
  567. }());
  568. // OPTIMIZATION: If LHS is a local, we can write the result directly into it.
  569. auto dst = [&] {
  570. if (lhs.operand().is_local())
  571. return lhs;
  572. return choose_dst(generator, preferred_dst);
  573. }();
  574. switch (m_op) {
  575. case AssignmentOp::AdditionAssignment:
  576. generator.emit<Bytecode::Op::Add>(dst, lhs, rhs);
  577. break;
  578. case AssignmentOp::SubtractionAssignment:
  579. generator.emit<Bytecode::Op::Sub>(dst, lhs, rhs);
  580. break;
  581. case AssignmentOp::MultiplicationAssignment:
  582. generator.emit<Bytecode::Op::Mul>(dst, lhs, rhs);
  583. break;
  584. case AssignmentOp::DivisionAssignment:
  585. generator.emit<Bytecode::Op::Div>(dst, lhs, rhs);
  586. break;
  587. case AssignmentOp::ModuloAssignment:
  588. generator.emit<Bytecode::Op::Mod>(dst, lhs, rhs);
  589. break;
  590. case AssignmentOp::ExponentiationAssignment:
  591. generator.emit<Bytecode::Op::Exp>(dst, lhs, rhs);
  592. break;
  593. case AssignmentOp::BitwiseAndAssignment:
  594. generator.emit<Bytecode::Op::BitwiseAnd>(dst, lhs, rhs);
  595. break;
  596. case AssignmentOp::BitwiseOrAssignment:
  597. generator.emit<Bytecode::Op::BitwiseOr>(dst, lhs, rhs);
  598. break;
  599. case AssignmentOp::BitwiseXorAssignment:
  600. generator.emit<Bytecode::Op::BitwiseXor>(dst, lhs, rhs);
  601. break;
  602. case AssignmentOp::LeftShiftAssignment:
  603. generator.emit<Bytecode::Op::LeftShift>(dst, lhs, rhs);
  604. break;
  605. case AssignmentOp::RightShiftAssignment:
  606. generator.emit<Bytecode::Op::RightShift>(dst, lhs, rhs);
  607. break;
  608. case AssignmentOp::UnsignedRightShiftAssignment:
  609. generator.emit<Bytecode::Op::UnsignedRightShift>(dst, lhs, rhs);
  610. break;
  611. case AssignmentOp::AndAssignment:
  612. case AssignmentOp::OrAssignment:
  613. case AssignmentOp::NullishAssignment:
  614. generator.emit<Bytecode::Op::Mov>(dst, rhs);
  615. break;
  616. default:
  617. return Bytecode::CodeGenerationError {
  618. this,
  619. "Unimplemented operation"sv,
  620. };
  621. }
  622. if (lhs_expression->is_identifier())
  623. generator.emit_set_variable(static_cast<Identifier const&>(*lhs_expression), dst);
  624. else
  625. (void)TRY(generator.emit_store_to_reference(reference_operands, dst));
  626. if (rhs_block_ptr) {
  627. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { *end_block_ptr });
  628. }
  629. if (lhs_block_ptr) {
  630. generator.switch_to_basic_block(*lhs_block_ptr);
  631. generator.emit<Bytecode::Op::Mov>(dst, lhs);
  632. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { *end_block_ptr });
  633. }
  634. if (end_block_ptr) {
  635. generator.switch_to_basic_block(*end_block_ptr);
  636. }
  637. return dst;
  638. }
  639. // 14.13.3 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-labelled-statements-runtime-semantics-evaluation
  640. // LabelledStatement : LabelIdentifier : LabelledItem
  641. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> LabelledStatement::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  642. {
  643. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  644. // Return ? LabelledEvaluation of this LabelledStatement with argument « ».
  645. return generate_labelled_evaluation(generator, {});
  646. }
  647. // 14.13.4 Runtime Semantics: LabelledEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-labelledevaluation
  648. // LabelledStatement : LabelIdentifier : LabelledItem
  649. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> LabelledStatement::generate_labelled_evaluation(Bytecode::Generator& generator, Vector<DeprecatedFlyString> const& label_set, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  650. {
  651. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  652. // Convert the m_labelled_item NNRP to a reference early so we don't have to do it every single time we want to use it.
  653. auto const& labelled_item = *m_labelled_item;
  654. // 1. Let label be the StringValue of LabelIdentifier.
  655. // NOTE: Not necessary, this is m_label.
  656. // 2. Let newLabelSet be the list-concatenation of labelSet and « label ».
  657. // FIXME: Avoid copy here.
  658. auto new_label_set = label_set;
  659. new_label_set.append(m_label);
  660. // 3. Let stmtResult be LabelledEvaluation of LabelledItem with argument newLabelSet.
  661. Optional<ScopedOperand> stmt_result;
  662. if (is<IterationStatement>(labelled_item)) {
  663. auto const& iteration_statement = static_cast<IterationStatement const&>(labelled_item);
  664. stmt_result = TRY(iteration_statement.generate_labelled_evaluation(generator, new_label_set));
  665. } else if (is<SwitchStatement>(labelled_item)) {
  666. auto const& switch_statement = static_cast<SwitchStatement const&>(labelled_item);
  667. stmt_result = TRY(switch_statement.generate_labelled_evaluation(generator, new_label_set));
  668. } else if (is<LabelledStatement>(labelled_item)) {
  669. auto const& labelled_statement = static_cast<LabelledStatement const&>(labelled_item);
  670. stmt_result = TRY(labelled_statement.generate_labelled_evaluation(generator, new_label_set));
  671. } else {
  672. auto& labelled_break_block = generator.make_block();
  673. // NOTE: We do not need a continuable scope as `continue;` is not allowed outside of iteration statements, throwing a SyntaxError in the parser.
  674. generator.begin_breakable_scope(Bytecode::Label { labelled_break_block }, new_label_set);
  675. stmt_result = TRY(labelled_item.generate_bytecode(generator));
  676. generator.end_breakable_scope();
  677. if (!generator.is_current_block_terminated()) {
  678. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { labelled_break_block });
  679. }
  680. generator.switch_to_basic_block(labelled_break_block);
  681. }
  682. // 4. If stmtResult.[[Type]] is break and SameValue(stmtResult.[[Target]], label) is true, then
  683. // a. Set stmtResult to NormalCompletion(stmtResult.[[Value]]).
  684. // NOTE: These steps are performed by making labelled break jump straight to the appropriate break block, which preserves the statement result's value in the accumulator.
  685. // 5. Return Completion(stmtResult).
  686. return stmt_result;
  687. }
  688. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> IterationStatement::generate_labelled_evaluation(Bytecode::Generator&, Vector<DeprecatedFlyString> const&, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  689. {
  690. return Bytecode::CodeGenerationError {
  691. this,
  692. "Missing generate_labelled_evaluation()"sv,
  693. };
  694. }
  695. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> WhileStatement::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  696. {
  697. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  698. return generate_labelled_evaluation(generator, {});
  699. }
  700. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> WhileStatement::generate_labelled_evaluation(Bytecode::Generator& generator, Vector<DeprecatedFlyString> const& label_set, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  701. {
  702. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  703. // test
  704. // jump if_false (true) end (false) body
  705. // body
  706. // jump always (true) test
  707. // end
  708. auto& test_block = generator.make_block();
  709. auto& body_block = generator.make_block();
  710. auto& end_block = generator.make_block();
  711. Optional<ScopedOperand> completion;
  712. if (generator.must_propagate_completion()) {
  713. completion = generator.allocate_register();
  714. generator.emit<Bytecode::Op::Mov>(*completion, generator.add_constant(js_undefined()));
  715. }
  716. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { test_block });
  717. generator.switch_to_basic_block(test_block);
  718. auto test = TRY(m_test->generate_bytecode(generator)).value();
  719. generator.emit_jump_if(
  720. test,
  721. Bytecode::Label { body_block },
  722. Bytecode::Label { end_block });
  723. generator.switch_to_basic_block(body_block);
  724. generator.begin_continuable_scope(Bytecode::Label { test_block }, label_set);
  725. generator.begin_breakable_scope(Bytecode::Label { end_block }, label_set);
  726. auto body = TRY(m_body->generate_bytecode(generator));
  727. generator.end_breakable_scope();
  728. generator.end_continuable_scope();
  729. if (!generator.is_current_block_terminated()) {
  730. if (generator.must_propagate_completion()) {
  731. if (body.has_value())
  732. generator.emit<Bytecode::Op::Mov>(*completion, body.value());
  733. }
  734. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { test_block });
  735. }
  736. generator.switch_to_basic_block(end_block);
  737. return completion;
  738. }
  739. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> DoWhileStatement::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  740. {
  741. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  742. return generate_labelled_evaluation(generator, {});
  743. }
  744. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> DoWhileStatement::generate_labelled_evaluation(Bytecode::Generator& generator, Vector<DeprecatedFlyString> const& label_set, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  745. {
  746. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  747. // jump always (true) body
  748. // test
  749. // jump if_false (true) end (false) body
  750. // body
  751. // jump always (true) test
  752. // end
  753. auto& body_block = generator.make_block();
  754. auto& test_block = generator.make_block();
  755. auto& load_result_and_jump_to_end_block = generator.make_block();
  756. auto& end_block = generator.make_block();
  757. Optional<ScopedOperand> completion;
  758. if (generator.must_propagate_completion()) {
  759. completion = generator.allocate_register();
  760. generator.emit<Bytecode::Op::Mov>(*completion, generator.add_constant(js_undefined()));
  761. }
  762. // jump to the body block
  763. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { body_block });
  764. generator.switch_to_basic_block(test_block);
  765. auto test = TRY(m_test->generate_bytecode(generator)).value();
  766. generator.emit_jump_if(
  767. test,
  768. Bytecode::Label { body_block },
  769. Bytecode::Label { load_result_and_jump_to_end_block });
  770. generator.switch_to_basic_block(body_block);
  771. generator.begin_continuable_scope(Bytecode::Label { test_block }, label_set);
  772. generator.begin_breakable_scope(Bytecode::Label { end_block }, label_set);
  773. auto body_result = TRY(m_body->generate_bytecode(generator));
  774. generator.end_breakable_scope();
  775. generator.end_continuable_scope();
  776. if (!generator.is_current_block_terminated()) {
  777. if (generator.must_propagate_completion()) {
  778. if (body_result.has_value())
  779. generator.emit<Bytecode::Op::Mov>(*completion, body_result.value());
  780. }
  781. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { test_block });
  782. }
  783. generator.switch_to_basic_block(load_result_and_jump_to_end_block);
  784. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { end_block });
  785. generator.switch_to_basic_block(end_block);
  786. return completion;
  787. }
  788. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ForStatement::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  789. {
  790. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  791. return generate_labelled_evaluation(generator, {});
  792. }
  793. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ForStatement::generate_labelled_evaluation(Bytecode::Generator& generator, Vector<DeprecatedFlyString> const& label_set, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  794. {
  795. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  796. // init
  797. // jump always (true) test
  798. // test
  799. // jump if_true (true) body (false) end
  800. // body
  801. // jump always (true) update
  802. // update
  803. // jump always (true) test
  804. // end
  805. // If 'test' is missing, fuse the 'test' and 'body' basic blocks
  806. // If 'update' is missing, fuse the 'body' and 'update' basic blocks
  807. Bytecode::BasicBlock* test_block_ptr { nullptr };
  808. Bytecode::BasicBlock* body_block_ptr { nullptr };
  809. Bytecode::BasicBlock* update_block_ptr { nullptr };
  810. bool has_lexical_environment = false;
  811. if (m_init) {
  812. if (m_init->is_variable_declaration()) {
  813. auto& variable_declaration = verify_cast<VariableDeclaration>(*m_init);
  814. auto has_non_local_variables = false;
  815. MUST(variable_declaration.for_each_bound_identifier([&](auto const& identifier) {
  816. if (!identifier.is_local())
  817. has_non_local_variables = true;
  818. }));
  819. if (variable_declaration.is_lexical_declaration() && has_non_local_variables) {
  820. has_lexical_environment = true;
  821. // FIXME: Is Block correct?
  822. generator.begin_variable_scope();
  823. bool is_const = variable_declaration.is_constant_declaration();
  824. // NOTE: Nothing in the callback throws an exception.
  825. MUST(variable_declaration.for_each_bound_identifier([&](auto const& identifier) {
  826. if (identifier.is_local())
  827. return;
  828. auto index = generator.intern_identifier(identifier.string());
  829. generator.emit<Bytecode::Op::CreateVariable>(index, Bytecode::Op::EnvironmentMode::Lexical, is_const);
  830. }));
  831. }
  832. }
  833. (void)TRY(m_init->generate_bytecode(generator));
  834. }
  835. body_block_ptr = &generator.make_block();
  836. if (m_update)
  837. update_block_ptr = &generator.make_block();
  838. else
  839. update_block_ptr = body_block_ptr;
  840. if (m_test)
  841. test_block_ptr = &generator.make_block();
  842. else
  843. test_block_ptr = body_block_ptr;
  844. auto& end_block = generator.make_block();
  845. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { *test_block_ptr });
  846. if (m_test) {
  847. generator.switch_to_basic_block(*test_block_ptr);
  848. auto test = TRY(m_test->generate_bytecode(generator)).value();
  849. generator.emit_jump_if(test, Bytecode::Label { *body_block_ptr }, Bytecode::Label { end_block });
  850. }
  851. if (m_update) {
  852. generator.switch_to_basic_block(*update_block_ptr);
  853. (void)TRY(m_update->generate_bytecode(generator));
  854. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { *test_block_ptr });
  855. }
  856. generator.switch_to_basic_block(*body_block_ptr);
  857. generator.begin_continuable_scope(Bytecode::Label { m_update ? *update_block_ptr : *test_block_ptr }, label_set);
  858. generator.begin_breakable_scope(Bytecode::Label { end_block }, label_set);
  859. auto body_result = TRY(m_body->generate_bytecode(generator));
  860. generator.end_breakable_scope();
  861. generator.end_continuable_scope();
  862. if (!generator.is_current_block_terminated()) {
  863. if (m_update) {
  864. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { *update_block_ptr });
  865. } else {
  866. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { *test_block_ptr });
  867. }
  868. }
  869. generator.switch_to_basic_block(end_block);
  870. if (has_lexical_environment)
  871. generator.end_variable_scope();
  872. return body_result;
  873. }
  874. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ObjectExpression::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  875. {
  876. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  877. auto object = generator.allocate_register();
  878. generator.emit<Bytecode::Op::NewObject>(object);
  879. if (m_properties.is_empty())
  880. return object;
  881. generator.push_home_object(object);
  882. for (auto& property : m_properties) {
  883. Bytecode::Op::PropertyKind property_kind;
  884. switch (property->type()) {
  885. case ObjectProperty::Type::KeyValue:
  886. property_kind = Bytecode::Op::PropertyKind::DirectKeyValue;
  887. break;
  888. case ObjectProperty::Type::Getter:
  889. property_kind = Bytecode::Op::PropertyKind::Getter;
  890. break;
  891. case ObjectProperty::Type::Setter:
  892. property_kind = Bytecode::Op::PropertyKind::Setter;
  893. break;
  894. case ObjectProperty::Type::Spread:
  895. property_kind = Bytecode::Op::PropertyKind::Spread;
  896. break;
  897. case ObjectProperty::Type::ProtoSetter:
  898. property_kind = Bytecode::Op::PropertyKind::ProtoSetter;
  899. break;
  900. }
  901. if (is<StringLiteral>(property->key())) {
  902. auto& string_literal = static_cast<StringLiteral const&>(property->key());
  903. Bytecode::IdentifierTableIndex key_name = generator.intern_identifier(string_literal.value());
  904. Optional<ScopedOperand> value;
  905. if (property_kind == Bytecode::Op::PropertyKind::ProtoSetter) {
  906. value = TRY(property->value().generate_bytecode(generator)).value();
  907. } else if (property_kind != Bytecode::Op::PropertyKind::Spread) {
  908. ByteString identifier = string_literal.value();
  909. if (property_kind == Bytecode::Op::PropertyKind::Getter)
  910. identifier = ByteString::formatted("get {}", identifier);
  911. else if (property_kind == Bytecode::Op::PropertyKind::Setter)
  912. identifier = ByteString::formatted("set {}", identifier);
  913. auto name = generator.intern_identifier(identifier);
  914. value = TRY(generator.emit_named_evaluation_if_anonymous_function(property->value(), name)).value();
  915. } else {
  916. // Spread the key.
  917. value = TRY(property->key().generate_bytecode(generator)).value();
  918. }
  919. generator.emit<Bytecode::Op::PutById>(object, key_name, *value, property_kind, generator.next_property_lookup_cache());
  920. } else {
  921. auto property_name = TRY(property->key().generate_bytecode(generator)).value();
  922. Optional<ScopedOperand> value;
  923. if (property_kind != Bytecode::Op::PropertyKind::Spread)
  924. value = TRY(property->value().generate_bytecode(generator)).value();
  925. else
  926. value = property_name;
  927. generator.emit<Bytecode::Op::PutByValue>(object, property_name, *value, property_kind);
  928. }
  929. }
  930. generator.pop_home_object();
  931. return object;
  932. }
  933. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ArrayExpression::generate_bytecode(Bytecode::Generator& generator, Optional<ScopedOperand> preferred_dst) const
  934. {
  935. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  936. if (m_elements.is_empty()) {
  937. auto dst = choose_dst(generator, preferred_dst);
  938. generator.emit<Bytecode::Op::NewArray>(dst);
  939. return dst;
  940. }
  941. if (all_of(m_elements, [](auto element) { return !element || is<PrimitiveLiteral>(*element); })) {
  942. // If all elements are constant primitives, we can just emit a single instruction to initialize the array,
  943. // instead of emitting instructions to manually evaluate them one-by-one
  944. Vector<Value> values;
  945. values.resize(m_elements.size());
  946. for (auto i = 0u; i < m_elements.size(); ++i) {
  947. if (!m_elements[i])
  948. continue;
  949. values[i] = static_cast<PrimitiveLiteral const&>(*m_elements[i]).value();
  950. }
  951. auto dst = choose_dst(generator, preferred_dst);
  952. generator.emit_with_extra_value_slots<Bytecode::Op::NewPrimitiveArray>(values.size(), dst, values);
  953. return dst;
  954. }
  955. auto first_spread = find_if(m_elements.begin(), m_elements.end(), [](auto el) { return el && is<SpreadExpression>(*el); });
  956. Vector<ScopedOperand> args;
  957. args.ensure_capacity(m_elements.size());
  958. for (auto it = m_elements.begin(); it != first_spread; ++it) {
  959. if (*it) {
  960. auto value = TRY((*it)->generate_bytecode(generator)).value();
  961. // NOTE: We don't need to protect temporary registers or constants from being clobbered.
  962. if (value.operand().is_register() || value.operand().is_constant()) {
  963. args.append(move(value));
  964. } else {
  965. auto reg = generator.allocate_register();
  966. generator.emit<Bytecode::Op::Mov>(Bytecode::Operand(reg), value);
  967. args.append(move(reg));
  968. }
  969. } else {
  970. args.append(generator.add_constant(Value()));
  971. }
  972. }
  973. auto dst = choose_dst(generator, preferred_dst);
  974. if (first_spread.index() != 0) {
  975. generator.emit_with_extra_operand_slots<Bytecode::Op::NewArray>(args.size(), dst, args);
  976. } else {
  977. generator.emit<Bytecode::Op::NewArray>(dst);
  978. }
  979. if (first_spread != m_elements.end()) {
  980. for (auto it = first_spread; it != m_elements.end(); ++it) {
  981. if (!*it) {
  982. generator.emit<Bytecode::Op::ArrayAppend>(dst, generator.add_constant(Value()), false);
  983. } else {
  984. auto value = TRY((*it)->generate_bytecode(generator)).value();
  985. generator.emit<Bytecode::Op::ArrayAppend>(dst, value, *it && is<SpreadExpression>(**it));
  986. }
  987. }
  988. }
  989. return dst;
  990. }
  991. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> MemberExpression::generate_bytecode(Bytecode::Generator& generator, Optional<ScopedOperand> preferred_dst) const
  992. {
  993. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  994. auto reference = TRY(generator.emit_load_from_reference(*this, preferred_dst));
  995. return reference.loaded_value;
  996. }
  997. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> FunctionDeclaration::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  998. {
  999. if (m_is_hoisted) {
  1000. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  1001. auto index = generator.intern_identifier(name());
  1002. auto value = generator.allocate_register();
  1003. generator.emit<Bytecode::Op::GetBinding>(value, index);
  1004. generator.emit<Bytecode::Op::SetVariableBinding>(index, value);
  1005. }
  1006. return Optional<ScopedOperand> {};
  1007. }
  1008. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> FunctionExpression::generate_bytecode_with_lhs_name(Bytecode::Generator& generator, Optional<Bytecode::IdentifierTableIndex> lhs_name, Optional<ScopedOperand> preferred_dst) const
  1009. {
  1010. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  1011. bool has_name = !name().is_empty();
  1012. Optional<Bytecode::IdentifierTableIndex> name_identifier;
  1013. if (has_name) {
  1014. generator.begin_variable_scope();
  1015. name_identifier = generator.intern_identifier(name());
  1016. generator.emit<Bytecode::Op::CreateVariable>(*name_identifier, Bytecode::Op::EnvironmentMode::Lexical, true);
  1017. }
  1018. auto new_function = choose_dst(generator, preferred_dst);
  1019. generator.emit_new_function(new_function, *this, lhs_name);
  1020. if (has_name) {
  1021. generator.emit<Bytecode::Op::InitializeLexicalBinding>(*name_identifier, new_function);
  1022. generator.end_variable_scope();
  1023. }
  1024. return new_function;
  1025. }
  1026. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> FunctionExpression::generate_bytecode(Bytecode::Generator& generator, Optional<ScopedOperand> preferred_dst) const
  1027. {
  1028. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  1029. return generate_bytecode_with_lhs_name(generator, {}, preferred_dst);
  1030. }
  1031. static Bytecode::CodeGenerationErrorOr<void> generate_object_binding_pattern_bytecode(Bytecode::Generator& generator, BindingPattern const& pattern, Bytecode::Op::BindingInitializationMode initialization_mode, ScopedOperand const& object, bool create_variables)
  1032. {
  1033. generator.emit<Bytecode::Op::ThrowIfNullish>(object);
  1034. Vector<ScopedOperand> excluded_property_names;
  1035. auto has_rest = false;
  1036. if (pattern.entries.size() > 0)
  1037. has_rest = pattern.entries[pattern.entries.size() - 1].is_rest;
  1038. for (auto& [name, alias, initializer, is_rest] : pattern.entries) {
  1039. if (is_rest) {
  1040. VERIFY(!initializer);
  1041. if (name.has<NonnullRefPtr<Identifier const>>()) {
  1042. auto identifier = name.get<NonnullRefPtr<Identifier const>>();
  1043. auto interned_identifier = generator.intern_identifier(identifier->string());
  1044. auto copy = generator.allocate_register();
  1045. generator.emit_with_extra_operand_slots<Bytecode::Op::CopyObjectExcludingProperties>(
  1046. excluded_property_names.size(), copy, object, excluded_property_names);
  1047. if (create_variables) {
  1048. VERIFY(!identifier->is_local());
  1049. generator.emit<Bytecode::Op::CreateVariable>(interned_identifier, Bytecode::Op::EnvironmentMode::Lexical, false);
  1050. }
  1051. generator.emit_set_variable(*identifier, copy, initialization_mode);
  1052. return {};
  1053. }
  1054. if (alias.has<NonnullRefPtr<MemberExpression const>>()) {
  1055. auto copy = generator.allocate_register();
  1056. generator.emit_with_extra_operand_slots<Bytecode::Op::CopyObjectExcludingProperties>(
  1057. excluded_property_names.size(), copy, object, excluded_property_names);
  1058. (void)TRY(generator.emit_store_to_reference(alias.get<NonnullRefPtr<MemberExpression const>>(), object));
  1059. return {};
  1060. }
  1061. VERIFY_NOT_REACHED();
  1062. }
  1063. auto value = generator.allocate_register();
  1064. if (name.has<NonnullRefPtr<Identifier const>>()) {
  1065. auto const& identifier = name.get<NonnullRefPtr<Identifier const>>()->string();
  1066. if (has_rest) {
  1067. excluded_property_names.append(generator.add_constant(PrimitiveString::create(generator.vm(), identifier), Bytecode::Generator::DeduplicateConstant::No));
  1068. }
  1069. generator.emit_get_by_id(value, object, generator.intern_identifier(identifier));
  1070. } else {
  1071. auto expression = name.get<NonnullRefPtr<Expression const>>();
  1072. auto property_name = TRY(expression->generate_bytecode(generator)).value();
  1073. if (has_rest) {
  1074. auto excluded_name = generator.allocate_register();
  1075. excluded_property_names.append(excluded_name);
  1076. generator.emit<Bytecode::Op::Mov>(excluded_name, property_name);
  1077. }
  1078. generator.emit<Bytecode::Op::GetByValue>(value, object, property_name);
  1079. }
  1080. if (initializer) {
  1081. auto& if_undefined_block = generator.make_block();
  1082. auto& if_not_undefined_block = generator.make_block();
  1083. generator.emit<Bytecode::Op::JumpUndefined>(
  1084. value,
  1085. Bytecode::Label { if_undefined_block },
  1086. Bytecode::Label { if_not_undefined_block });
  1087. generator.switch_to_basic_block(if_undefined_block);
  1088. Optional<ScopedOperand> default_value;
  1089. if (auto const* alias_identifier = alias.get_pointer<NonnullRefPtr<Identifier const>>()) {
  1090. default_value = TRY(generator.emit_named_evaluation_if_anonymous_function(*initializer, generator.intern_identifier((*alias_identifier)->string()))).value();
  1091. } else if (auto const* lhs = name.get_pointer<NonnullRefPtr<Identifier const>>()) {
  1092. default_value = TRY(generator.emit_named_evaluation_if_anonymous_function(*initializer, generator.intern_identifier((*lhs)->string()))).value();
  1093. } else {
  1094. default_value = TRY(initializer->generate_bytecode(generator)).value();
  1095. }
  1096. generator.emit<Bytecode::Op::Mov>(value, *default_value);
  1097. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { if_not_undefined_block });
  1098. generator.switch_to_basic_block(if_not_undefined_block);
  1099. }
  1100. if (alias.has<NonnullRefPtr<BindingPattern const>>()) {
  1101. auto& binding_pattern = *alias.get<NonnullRefPtr<BindingPattern const>>();
  1102. auto nested_value = generator.allocate_register();
  1103. generator.emit<Bytecode::Op::Mov>(nested_value, value);
  1104. TRY(binding_pattern.generate_bytecode(generator, initialization_mode, nested_value, create_variables));
  1105. } else if (alias.has<Empty>()) {
  1106. if (name.has<NonnullRefPtr<Expression const>>()) {
  1107. // This needs some sort of SetVariableByValue opcode, as it's a runtime binding
  1108. return Bytecode::CodeGenerationError {
  1109. name.get<NonnullRefPtr<Expression const>>().ptr(),
  1110. "Unimplemented name/alias pair: Empty/Expression"sv,
  1111. };
  1112. }
  1113. auto const& identifier = *name.get<NonnullRefPtr<Identifier const>>();
  1114. auto identifier_ref = generator.intern_identifier(identifier.string());
  1115. if (create_variables)
  1116. generator.emit<Bytecode::Op::CreateVariable>(identifier_ref, Bytecode::Op::EnvironmentMode::Lexical, false);
  1117. generator.emit_set_variable(identifier, value, initialization_mode);
  1118. } else if (alias.has<NonnullRefPtr<MemberExpression const>>()) {
  1119. TRY(generator.emit_store_to_reference(alias.get<NonnullRefPtr<MemberExpression const>>(), value));
  1120. } else {
  1121. auto const& identifier = *alias.get<NonnullRefPtr<Identifier const>>();
  1122. auto identifier_ref = generator.intern_identifier(identifier.string());
  1123. if (create_variables)
  1124. generator.emit<Bytecode::Op::CreateVariable>(identifier_ref, Bytecode::Op::EnvironmentMode::Lexical, false);
  1125. generator.emit_set_variable(identifier, value, initialization_mode);
  1126. }
  1127. }
  1128. return {};
  1129. }
  1130. static Bytecode::CodeGenerationErrorOr<void> generate_array_binding_pattern_bytecode(Bytecode::Generator& generator, BindingPattern const& pattern, Bytecode::Op::BindingInitializationMode initialization_mode, ScopedOperand const& input_array, bool create_variables, [[maybe_unused]] Optional<ScopedOperand> preferred_dst = {})
  1131. {
  1132. /*
  1133. * Consider the following destructuring assignment:
  1134. *
  1135. * let [a, b, c, d, e] = o;
  1136. *
  1137. * It would be fairly trivial to just loop through this iterator, getting the value
  1138. * at each step and assigning them to the binding sequentially. However, this is not
  1139. * correct: once an iterator is exhausted, it must not be called again. This complicates
  1140. * the bytecode. In order to accomplish this, we do the following:
  1141. *
  1142. * - Reserve a special boolean register which holds 'true' if the iterator is exhausted,
  1143. * and false otherwise
  1144. * - When we are retrieving the value which should be bound, we first check this register.
  1145. * If it is 'true', we load undefined. Otherwise, we grab the next value from the iterator.
  1146. *
  1147. * Note that the is_exhausted register does not need to be loaded with false because the
  1148. * first IteratorNext bytecode is _not_ proceeded by an exhausted check, as it is
  1149. * unnecessary.
  1150. */
  1151. auto is_iterator_exhausted = generator.allocate_register();
  1152. generator.emit<Bytecode::Op::Mov>(is_iterator_exhausted, generator.add_constant(Value(false)));
  1153. auto iterator = generator.allocate_register();
  1154. generator.emit<Bytecode::Op::GetIterator>(iterator, input_array);
  1155. bool first = true;
  1156. auto assign_value_to_alias = [&](auto& alias, ScopedOperand value) {
  1157. return alias.visit(
  1158. [&](Empty) -> Bytecode::CodeGenerationErrorOr<void> {
  1159. // This element is an elision
  1160. return {};
  1161. },
  1162. [&](NonnullRefPtr<Identifier const> const& identifier) -> Bytecode::CodeGenerationErrorOr<void> {
  1163. auto interned_index = generator.intern_identifier(identifier->string());
  1164. if (create_variables)
  1165. generator.emit<Bytecode::Op::CreateVariable>(interned_index, Bytecode::Op::EnvironmentMode::Lexical, false);
  1166. generator.emit_set_variable(*identifier, value, initialization_mode);
  1167. return {};
  1168. },
  1169. [&](NonnullRefPtr<BindingPattern const> const& pattern) -> Bytecode::CodeGenerationErrorOr<void> {
  1170. return pattern->generate_bytecode(generator, initialization_mode, value, create_variables);
  1171. },
  1172. [&](NonnullRefPtr<MemberExpression const> const& expr) -> Bytecode::CodeGenerationErrorOr<void> {
  1173. (void)generator.emit_store_to_reference(*expr, value);
  1174. return {};
  1175. });
  1176. };
  1177. auto temp_iterator_result = generator.allocate_register();
  1178. for (auto& [name, alias, initializer, is_rest] : pattern.entries) {
  1179. VERIFY(name.has<Empty>());
  1180. if (is_rest) {
  1181. VERIFY(!initializer);
  1182. auto value = generator.allocate_register();
  1183. if (first) {
  1184. // The iterator has not been called, and is thus known to be not exhausted
  1185. generator.emit<Bytecode::Op::IteratorToArray>(value, iterator);
  1186. } else {
  1187. auto& if_exhausted_block = generator.make_block();
  1188. auto& if_not_exhausted_block = generator.make_block();
  1189. auto& continuation_block = generator.make_block();
  1190. generator.emit_jump_if(
  1191. is_iterator_exhausted,
  1192. Bytecode::Label { if_exhausted_block },
  1193. Bytecode::Label { if_not_exhausted_block });
  1194. value = generator.allocate_register();
  1195. generator.switch_to_basic_block(if_exhausted_block);
  1196. generator.emit<Bytecode::Op::NewArray>(value);
  1197. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { continuation_block });
  1198. generator.switch_to_basic_block(if_not_exhausted_block);
  1199. generator.emit<Bytecode::Op::IteratorToArray>(value, iterator);
  1200. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { continuation_block });
  1201. generator.switch_to_basic_block(continuation_block);
  1202. }
  1203. return assign_value_to_alias(alias, value);
  1204. }
  1205. auto& iterator_is_exhausted_block = generator.make_block();
  1206. if (!first) {
  1207. auto& iterator_is_not_exhausted_block = generator.make_block();
  1208. generator.emit_jump_if(
  1209. is_iterator_exhausted,
  1210. Bytecode::Label { iterator_is_exhausted_block },
  1211. Bytecode::Label { iterator_is_not_exhausted_block });
  1212. generator.switch_to_basic_block(iterator_is_not_exhausted_block);
  1213. }
  1214. generator.emit<Bytecode::Op::IteratorNext>(temp_iterator_result, iterator);
  1215. generator.emit_iterator_complete(is_iterator_exhausted, temp_iterator_result);
  1216. // We still have to check for exhaustion here. If the iterator is exhausted,
  1217. // we need to bail before trying to get the value
  1218. auto& no_bail_block = generator.make_block();
  1219. generator.emit_jump_if(
  1220. is_iterator_exhausted,
  1221. Bytecode::Label { iterator_is_exhausted_block },
  1222. Bytecode::Label { no_bail_block });
  1223. generator.switch_to_basic_block(no_bail_block);
  1224. // Get the next value in the iterator
  1225. auto value = generator.allocate_register();
  1226. generator.emit_iterator_value(value, temp_iterator_result);
  1227. auto& create_binding_block = generator.make_block();
  1228. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { create_binding_block });
  1229. // The iterator is exhausted, so we just load undefined and continue binding
  1230. generator.switch_to_basic_block(iterator_is_exhausted_block);
  1231. generator.emit<Bytecode::Op::Mov>(value, generator.add_constant(js_undefined()));
  1232. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { create_binding_block });
  1233. generator.switch_to_basic_block(create_binding_block);
  1234. if (initializer) {
  1235. auto& value_is_undefined_block = generator.make_block();
  1236. auto& value_is_not_undefined_block = generator.make_block();
  1237. generator.emit<Bytecode::Op::JumpUndefined>(
  1238. value,
  1239. Bytecode::Label { value_is_undefined_block },
  1240. Bytecode::Label { value_is_not_undefined_block });
  1241. generator.switch_to_basic_block(value_is_undefined_block);
  1242. Optional<ScopedOperand> default_value;
  1243. if (auto const* alias_identifier = alias.get_pointer<NonnullRefPtr<Identifier const>>()) {
  1244. default_value = TRY(generator.emit_named_evaluation_if_anonymous_function(*initializer, generator.intern_identifier((*alias_identifier)->string()))).value();
  1245. } else if (auto const* name_identifier = name.get_pointer<NonnullRefPtr<Identifier const>>()) {
  1246. default_value = TRY(generator.emit_named_evaluation_if_anonymous_function(*initializer, generator.intern_identifier((*name_identifier)->string()))).value();
  1247. } else {
  1248. default_value = TRY(initializer->generate_bytecode(generator)).value();
  1249. }
  1250. generator.emit<Bytecode::Op::Mov>(value, *default_value);
  1251. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { value_is_not_undefined_block });
  1252. generator.switch_to_basic_block(value_is_not_undefined_block);
  1253. }
  1254. TRY(assign_value_to_alias(alias, value));
  1255. first = false;
  1256. }
  1257. auto& done_block = generator.make_block();
  1258. auto& not_done_block = generator.make_block();
  1259. generator.emit_jump_if(
  1260. is_iterator_exhausted,
  1261. Bytecode::Label { done_block },
  1262. Bytecode::Label { not_done_block });
  1263. generator.switch_to_basic_block(not_done_block);
  1264. generator.emit<Bytecode::Op::IteratorClose>(iterator, Completion::Type::Normal, Optional<Value> {});
  1265. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { done_block });
  1266. generator.switch_to_basic_block(done_block);
  1267. return {};
  1268. }
  1269. Bytecode::CodeGenerationErrorOr<void> BindingPattern::generate_bytecode(Bytecode::Generator& generator, Bytecode::Op::BindingInitializationMode initialization_mode, ScopedOperand const& input_value, bool create_variables) const
  1270. {
  1271. if (kind == Kind::Object)
  1272. return generate_object_binding_pattern_bytecode(generator, *this, initialization_mode, input_value, create_variables);
  1273. return generate_array_binding_pattern_bytecode(generator, *this, initialization_mode, input_value, create_variables);
  1274. }
  1275. static Bytecode::CodeGenerationErrorOr<void> assign_value_to_variable_declarator(Bytecode::Generator& generator, VariableDeclarator const& declarator, VariableDeclaration const& declaration, ScopedOperand value)
  1276. {
  1277. auto initialization_mode = declaration.is_lexical_declaration() ? Bytecode::Op::BindingInitializationMode::Initialize : Bytecode::Op::BindingInitializationMode::Set;
  1278. return declarator.target().visit(
  1279. [&](NonnullRefPtr<Identifier const> const& id) -> Bytecode::CodeGenerationErrorOr<void> {
  1280. generator.emit_set_variable(*id, value, initialization_mode);
  1281. return {};
  1282. },
  1283. [&](NonnullRefPtr<BindingPattern const> const& pattern) -> Bytecode::CodeGenerationErrorOr<void> {
  1284. return pattern->generate_bytecode(generator, initialization_mode, value, false);
  1285. });
  1286. }
  1287. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> VariableDeclaration::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  1288. {
  1289. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  1290. for (auto& declarator : m_declarations) {
  1291. // NOTE: `var` declarations can have duplicates, but duplicate `let` or `const` bindings are a syntax error.
  1292. // Because of this, we can sink `let` and `const` directly into the preferred_dst if available.
  1293. // This is not safe for `var` since the preferred_dst may be used in the initializer.
  1294. Optional<ScopedOperand> init_dst;
  1295. if (declaration_kind() != DeclarationKind::Var) {
  1296. if (auto const* identifier = declarator->target().get_pointer<NonnullRefPtr<Identifier const>>()) {
  1297. if ((*identifier)->is_local()) {
  1298. init_dst = generator.local((*identifier)->local_variable_index());
  1299. }
  1300. }
  1301. }
  1302. if (declarator->init()) {
  1303. auto value = TRY([&]() -> Bytecode::CodeGenerationErrorOr<ScopedOperand> {
  1304. if (auto const* lhs = declarator->target().get_pointer<NonnullRefPtr<Identifier const>>()) {
  1305. return TRY(generator.emit_named_evaluation_if_anonymous_function(*declarator->init(), generator.intern_identifier((*lhs)->string()), init_dst)).value();
  1306. } else {
  1307. return TRY(declarator->init()->generate_bytecode(generator, init_dst)).value();
  1308. }
  1309. }());
  1310. (void)TRY(assign_value_to_variable_declarator(generator, declarator, *this, value));
  1311. } else if (m_declaration_kind != DeclarationKind::Var) {
  1312. (void)TRY(assign_value_to_variable_declarator(generator, declarator, *this, generator.add_constant(js_undefined())));
  1313. }
  1314. }
  1315. for (auto& declarator : m_declarations) {
  1316. if (auto const* identifier = declarator->target().get_pointer<NonnullRefPtr<Identifier const>>()) {
  1317. if ((*identifier)->is_local()) {
  1318. generator.set_local_initialized((*identifier)->local_variable_index());
  1319. }
  1320. }
  1321. }
  1322. // NOTE: VariableDeclaration doesn't return a completion value.
  1323. return Optional<ScopedOperand> {};
  1324. }
  1325. struct BaseAndValue {
  1326. ScopedOperand base;
  1327. ScopedOperand value;
  1328. };
  1329. static Bytecode::CodeGenerationErrorOr<BaseAndValue> get_base_and_value_from_member_expression(Bytecode::Generator& generator, MemberExpression const& member_expression)
  1330. {
  1331. // https://tc39.es/ecma262/#sec-super-keyword-runtime-semantics-evaluation
  1332. if (is<SuperExpression>(member_expression.object())) {
  1333. // 1. Let env be GetThisEnvironment().
  1334. // 2. Let actualThis be ? env.GetThisBinding().
  1335. auto this_value = generator.get_this();
  1336. Optional<ScopedOperand> computed_property;
  1337. if (member_expression.is_computed()) {
  1338. // SuperProperty : super [ Expression ]
  1339. // 3. Let propertyNameReference be ? Evaluation of Expression.
  1340. // 4. Let propertyNameValue be ? GetValue(propertyNameReference).
  1341. computed_property = TRY(member_expression.property().generate_bytecode(generator));
  1342. }
  1343. // 5/7. Return ? MakeSuperPropertyReference(actualThis, propertyKey, strict).
  1344. // https://tc39.es/ecma262/#sec-makesuperpropertyreference
  1345. // 1. Let env be GetThisEnvironment().
  1346. // 2. Assert: env.HasSuperBinding() is true.
  1347. // 3. Let baseValue be ? env.GetSuperBase().
  1348. auto super_base = generator.allocate_register();
  1349. generator.emit<Bytecode::Op::ResolveSuperBase>(super_base);
  1350. auto value = generator.allocate_register();
  1351. // 4. Return the Reference Record { [[Base]]: baseValue, [[ReferencedName]]: propertyKey, [[Strict]]: strict, [[ThisValue]]: actualThis }.
  1352. if (computed_property.has_value()) {
  1353. // 5. Let propertyKey be ? ToPropertyKey(propertyNameValue).
  1354. // FIXME: This does ToPropertyKey out of order, which is observable by Symbol.toPrimitive!
  1355. generator.emit<Bytecode::Op::GetByValueWithThis>(value, super_base, *computed_property, this_value);
  1356. } else {
  1357. // 3. Let propertyKey be StringValue of IdentifierName.
  1358. auto identifier_table_ref = generator.intern_identifier(verify_cast<Identifier>(member_expression.property()).string());
  1359. generator.emit_get_by_id_with_this(value, super_base, identifier_table_ref, this_value);
  1360. }
  1361. return BaseAndValue { this_value, value };
  1362. }
  1363. auto base = TRY(member_expression.object().generate_bytecode(generator)).value();
  1364. auto value = generator.allocate_register();
  1365. if (member_expression.is_computed()) {
  1366. auto property = TRY(member_expression.property().generate_bytecode(generator)).value();
  1367. generator.emit<Bytecode::Op::GetByValue>(value, base, property);
  1368. } else if (is<PrivateIdentifier>(member_expression.property())) {
  1369. generator.emit<Bytecode::Op::GetPrivateById>(
  1370. value,
  1371. base,
  1372. generator.intern_identifier(verify_cast<PrivateIdentifier>(member_expression.property()).string()));
  1373. } else {
  1374. auto base_identifier = generator.intern_identifier_for_expression(member_expression.object());
  1375. generator.emit_get_by_id(value, base, generator.intern_identifier(verify_cast<Identifier>(member_expression.property()).string()), move(base_identifier));
  1376. }
  1377. return BaseAndValue { base, value };
  1378. }
  1379. static Bytecode::CodeGenerationErrorOr<void> generate_optional_chain(Bytecode::Generator& generator, OptionalChain const& optional_chain, ScopedOperand current_value, ScopedOperand current_base, [[maybe_unused]] Optional<ScopedOperand> preferred_dst = {});
  1380. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> CallExpression::generate_bytecode(Bytecode::Generator& generator, Optional<ScopedOperand> preferred_dst) const
  1381. {
  1382. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  1383. Optional<Bytecode::Builtin> builtin;
  1384. Optional<ScopedOperand> original_callee;
  1385. auto this_value = generator.add_constant(js_undefined());
  1386. if (is<NewExpression>(this)) {
  1387. original_callee = TRY(m_callee->generate_bytecode(generator)).value();
  1388. } else if (is<MemberExpression>(*m_callee)) {
  1389. auto& member_expression = static_cast<MemberExpression const&>(*m_callee);
  1390. auto base_and_value = TRY(get_base_and_value_from_member_expression(generator, member_expression));
  1391. original_callee = base_and_value.value;
  1392. this_value = base_and_value.base;
  1393. builtin = Bytecode::get_builtin(member_expression);
  1394. } else if (is<OptionalChain>(*m_callee)) {
  1395. auto& optional_chain = static_cast<OptionalChain const&>(*m_callee);
  1396. original_callee = generator.allocate_register();
  1397. this_value = generator.allocate_register();
  1398. TRY(generate_optional_chain(generator, optional_chain, *original_callee, this_value));
  1399. } else if (is<Identifier>(*m_callee)) {
  1400. // If the original_callee is an identifier, we may need to extract a `this` value.
  1401. // This is important when we're inside a `with` statement and calling a method on
  1402. // the environment's binding object.
  1403. // NOTE: If the identifier refers to a known "local" or "global", we know it can't be
  1404. // a `with` binding, so we can skip this.
  1405. auto& identifier = static_cast<Identifier const&>(*m_callee);
  1406. if (identifier.is_local()) {
  1407. auto local = generator.local(identifier.local_variable_index());
  1408. if (!generator.is_local_initialized(local.operand().index())) {
  1409. generator.emit<Bytecode::Op::ThrowIfTDZ>(local);
  1410. }
  1411. original_callee = local;
  1412. } else if (identifier.is_global()) {
  1413. original_callee = m_callee->generate_bytecode(generator).value();
  1414. } else {
  1415. original_callee = generator.allocate_register();
  1416. this_value = generator.allocate_register();
  1417. generator.emit<Bytecode::Op::GetCalleeAndThisFromEnvironment>(
  1418. *original_callee,
  1419. this_value,
  1420. generator.intern_identifier(identifier.string()));
  1421. }
  1422. } else {
  1423. // FIXME: this = global object in sloppy mode.
  1424. original_callee = TRY(m_callee->generate_bytecode(generator)).value();
  1425. }
  1426. // NOTE: If the callee isn't already a temporary, we copy it to a new register
  1427. // to avoid overwriting it while evaluating arguments.
  1428. auto callee = [&]() -> ScopedOperand {
  1429. if (!original_callee->operand().is_register()) {
  1430. auto callee = generator.allocate_register();
  1431. generator.emit<Bytecode::Op::Mov>(callee, *original_callee);
  1432. return callee;
  1433. }
  1434. return *original_callee;
  1435. }();
  1436. Bytecode::Op::CallType call_type;
  1437. if (is<NewExpression>(*this)) {
  1438. call_type = Bytecode::Op::CallType::Construct;
  1439. } else if (m_callee->is_identifier() && static_cast<Identifier const&>(*m_callee).string() == "eval"sv) {
  1440. call_type = Bytecode::Op::CallType::DirectEval;
  1441. } else {
  1442. call_type = Bytecode::Op::CallType::Call;
  1443. }
  1444. Optional<Bytecode::StringTableIndex> expression_string_index;
  1445. if (auto expression_string = this->expression_string(); expression_string.has_value())
  1446. expression_string_index = generator.intern_string(expression_string.release_value());
  1447. bool has_spread = any_of(arguments(), [](auto& argument) { return argument.is_spread; });
  1448. auto dst = choose_dst(generator, preferred_dst);
  1449. if (has_spread) {
  1450. auto arguments = TRY(arguments_to_array_for_call(generator, this->arguments())).value();
  1451. generator.emit<Bytecode::Op::CallWithArgumentArray>(call_type, dst, callee, this_value, arguments, expression_string_index);
  1452. } else {
  1453. Vector<ScopedOperand> argument_operands;
  1454. argument_operands.ensure_capacity(arguments().size());
  1455. for (auto const& argument : arguments()) {
  1456. auto argument_value = TRY(argument.value->generate_bytecode(generator)).value();
  1457. // NOTE: We don't need to protect temporary registers or constants from being clobbered.
  1458. if (argument_value.operand().is_register() || argument_value.operand().is_constant()) {
  1459. argument_operands.append(argument_value);
  1460. } else {
  1461. auto temporary = generator.allocate_register();
  1462. generator.emit<Bytecode::Op::Mov>(temporary, argument_value);
  1463. argument_operands.append(temporary);
  1464. }
  1465. }
  1466. generator.emit_with_extra_operand_slots<Bytecode::Op::Call>(
  1467. argument_operands.size(),
  1468. call_type,
  1469. dst,
  1470. callee,
  1471. this_value,
  1472. argument_operands,
  1473. expression_string_index,
  1474. builtin);
  1475. }
  1476. return dst;
  1477. }
  1478. static ScopedOperand generate_await(
  1479. Bytecode::Generator& generator,
  1480. ScopedOperand argument,
  1481. ScopedOperand received_completion,
  1482. ScopedOperand received_completion_type,
  1483. ScopedOperand received_completion_value,
  1484. Bytecode::IdentifierTableIndex type_identifier,
  1485. Bytecode::IdentifierTableIndex value_identifier);
  1486. // https://tc39.es/ecma262/#sec-return-statement-runtime-semantics-evaluation
  1487. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ReturnStatement::generate_bytecode(Bytecode::Generator& generator, Optional<ScopedOperand>) const
  1488. {
  1489. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  1490. Optional<ScopedOperand> return_value;
  1491. if (m_argument) {
  1492. // ReturnStatement : return Expression ;
  1493. // 1. Let exprRef be ? Evaluation of Expression.
  1494. // 2. Let exprValue be ? GetValue(exprRef).
  1495. return_value = TRY(m_argument->generate_bytecode(generator)).value();
  1496. // 3. If GetGeneratorKind() is async, set exprValue to ? Await(exprValue).
  1497. // Spec Issue?: The spec doesn't seem to do implicit await on explicit return for async functions, but does for
  1498. // async generators. However, the major engines do so, and this is observable via constructor lookups
  1499. // on Promise objects and custom thenables.
  1500. // See: https://tc39.es/ecma262/#sec-asyncblockstart
  1501. // c. Assert: If we return here, the async function either threw an exception or performed an implicit or explicit return; all awaiting is done.
  1502. if (generator.is_in_async_function()) {
  1503. auto received_completion = generator.allocate_register();
  1504. auto received_completion_type = generator.allocate_register();
  1505. auto received_completion_value = generator.allocate_register();
  1506. auto type_identifier = generator.intern_identifier("type");
  1507. auto value_identifier = generator.intern_identifier("value");
  1508. return_value = generate_await(generator, *return_value, received_completion, received_completion_type, received_completion_value, type_identifier, value_identifier);
  1509. }
  1510. // 4. Return Completion Record { [[Type]]: return, [[Value]]: exprValue, [[Target]]: empty }.
  1511. } else {
  1512. // ReturnStatement : return ;
  1513. // 1. Return Completion Record { [[Type]]: return, [[Value]]: undefined, [[Target]]: empty }.
  1514. return_value = generator.add_constant(js_undefined());
  1515. }
  1516. if (generator.is_in_generator_or_async_function())
  1517. generator.emit_return<Bytecode::Op::Yield>(return_value.value());
  1518. else
  1519. generator.emit_return<Bytecode::Op::Return>(return_value.value());
  1520. return return_value;
  1521. }
  1522. static void get_received_completion_type_and_value(
  1523. Bytecode::Generator& generator,
  1524. ScopedOperand received_completion,
  1525. ScopedOperand received_completion_type,
  1526. ScopedOperand received_completion_value,
  1527. Bytecode::IdentifierTableIndex type_identifier,
  1528. Bytecode::IdentifierTableIndex value_identifier)
  1529. {
  1530. generator.emit_get_by_id(received_completion_type, received_completion, type_identifier);
  1531. generator.emit_get_by_id(received_completion_value, received_completion, value_identifier);
  1532. }
  1533. enum class AwaitBeforeYield {
  1534. No,
  1535. Yes,
  1536. };
  1537. static void generate_yield(Bytecode::Generator& generator,
  1538. Bytecode::Label continuation_label,
  1539. ScopedOperand argument,
  1540. ScopedOperand received_completion,
  1541. ScopedOperand received_completion_type,
  1542. ScopedOperand received_completion_value,
  1543. Bytecode::IdentifierTableIndex type_identifier,
  1544. Bytecode::IdentifierTableIndex value_identifier,
  1545. AwaitBeforeYield await_before_yield)
  1546. {
  1547. if (!generator.is_in_async_generator_function()) {
  1548. generator.emit<Bytecode::Op::Yield>(Bytecode::Label { continuation_label }, argument);
  1549. return;
  1550. }
  1551. if (await_before_yield == AwaitBeforeYield::Yes)
  1552. argument = generate_await(generator, argument, received_completion, received_completion_type, received_completion_value, type_identifier, value_identifier);
  1553. auto& unwrap_yield_resumption_block = generator.make_block();
  1554. generator.emit<Bytecode::Op::Yield>(Bytecode::Label { unwrap_yield_resumption_block }, argument);
  1555. generator.switch_to_basic_block(unwrap_yield_resumption_block);
  1556. generator.emit<Bytecode::Op::Mov>(received_completion, generator.accumulator());
  1557. get_received_completion_type_and_value(generator, received_completion, received_completion_type, received_completion_value, type_identifier, value_identifier);
  1558. // 27.6.3.7 AsyncGeneratorUnwrapYieldResumption ( resumptionValue ), https://tc39.es/ecma262/#sec-asyncgeneratorunwrapyieldresumption
  1559. // 1. If resumptionValue.[[Type]] is not return, return ? resumptionValue.
  1560. auto& resumption_value_type_is_return_block = generator.make_block();
  1561. auto resumption_value_type_is_not_return_result = generator.allocate_register();
  1562. generator.emit<Bytecode::Op::StrictlyInequals>(
  1563. resumption_value_type_is_not_return_result,
  1564. received_completion_type,
  1565. generator.add_constant(Value(to_underlying(Completion::Type::Return))));
  1566. generator.emit_jump_if(
  1567. resumption_value_type_is_not_return_result,
  1568. Bytecode::Label { continuation_label },
  1569. Bytecode::Label { resumption_value_type_is_return_block });
  1570. generator.switch_to_basic_block(resumption_value_type_is_return_block);
  1571. // 2. Let awaited be Completion(Await(resumptionValue.[[Value]])).
  1572. generate_await(generator, received_completion_value, received_completion, received_completion_type, received_completion_value, type_identifier, value_identifier);
  1573. // 3. If awaited.[[Type]] is throw, return ? awaited.
  1574. auto& awaited_type_is_normal_block = generator.make_block();
  1575. auto awaited_type_is_throw_result = generator.allocate_register();
  1576. generator.emit<Bytecode::Op::StrictlyEquals>(
  1577. awaited_type_is_throw_result,
  1578. received_completion_type,
  1579. generator.add_constant(Value(to_underlying(Completion::Type::Throw))));
  1580. generator.emit_jump_if(
  1581. awaited_type_is_throw_result,
  1582. Bytecode::Label { continuation_label },
  1583. Bytecode::Label { awaited_type_is_normal_block });
  1584. // 4. Assert: awaited.[[Type]] is normal.
  1585. generator.switch_to_basic_block(awaited_type_is_normal_block);
  1586. // 5. Return Completion Record { [[Type]]: return, [[Value]]: awaited.[[Value]], [[Target]]: empty }.
  1587. generator.emit<Bytecode::Op::PutById>(
  1588. received_completion,
  1589. type_identifier,
  1590. generator.add_constant(Value(to_underlying(Completion::Type::Return))),
  1591. Bytecode::Op::PropertyKind::KeyValue,
  1592. generator.next_property_lookup_cache());
  1593. generator.emit<Bytecode::Op::Jump>(continuation_label);
  1594. }
  1595. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> YieldExpression::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  1596. {
  1597. // Note: We need to catch any scheduled exceptions and reschedule them on re-entry
  1598. // as the act of yielding would otherwise clear them out
  1599. // This only applies when we are in a finalizer
  1600. bool is_in_finalizer = generator.is_in_finalizer();
  1601. Optional<ScopedOperand> saved_exception;
  1602. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  1603. VERIFY(generator.is_in_generator_function());
  1604. auto received_completion = generator.allocate_register();
  1605. auto received_completion_type = generator.allocate_register();
  1606. auto received_completion_value = generator.allocate_register();
  1607. auto type_identifier = generator.intern_identifier("type");
  1608. auto value_identifier = generator.intern_identifier("value");
  1609. if (m_is_yield_from) {
  1610. // 15.5.5 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-generator-function-definitions-runtime-semantics-evaluation
  1611. // 1. Let generatorKind be GetGeneratorKind().
  1612. // NOTE: is_in_async_generator_function differentiates the generator kind.
  1613. // 2. Let exprRef be ? Evaluation of AssignmentExpression.
  1614. // 3. Let value be ? GetValue(exprRef).
  1615. VERIFY(m_argument);
  1616. auto value = TRY(m_argument->generate_bytecode(generator)).value();
  1617. // 4. Let iteratorRecord be ? GetIterator(value, generatorKind).
  1618. auto iterator_record = generator.allocate_register();
  1619. auto iterator_hint = generator.is_in_async_generator_function() ? IteratorHint::Async : IteratorHint::Sync;
  1620. generator.emit<Bytecode::Op::GetIterator>(iterator_record, value, iterator_hint);
  1621. // 5. Let iterator be iteratorRecord.[[Iterator]].
  1622. auto iterator = generator.allocate_register();
  1623. generator.emit<Bytecode::Op::GetObjectFromIteratorRecord>(iterator, iterator_record);
  1624. // Cache iteratorRecord.[[NextMethod]] for use in step 7.a.i.
  1625. auto next_method = generator.allocate_register();
  1626. generator.emit<Bytecode::Op::GetNextMethodFromIteratorRecord>(next_method, iterator_record);
  1627. // 6. Let received be NormalCompletion(undefined).
  1628. // See get_received_completion_type_and_value above.
  1629. generator.emit<Bytecode::Op::Mov>(received_completion_type, generator.add_constant(Value(to_underlying(Completion::Type::Normal))));
  1630. generator.emit<Bytecode::Op::Mov>(received_completion_value, generator.add_constant(js_undefined()));
  1631. // 7. Repeat,
  1632. auto& loop_block = generator.make_block();
  1633. auto& continuation_block = generator.make_block();
  1634. auto& loop_end_block = generator.make_block();
  1635. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { loop_block });
  1636. generator.switch_to_basic_block(loop_block);
  1637. // a. If received.[[Type]] is normal, then
  1638. auto& type_is_normal_block = generator.make_block();
  1639. auto& is_type_throw_block = generator.make_block();
  1640. auto received_completion_type_register_is_normal = generator.allocate_register();
  1641. generator.emit<Bytecode::Op::StrictlyEquals>(
  1642. received_completion_type_register_is_normal,
  1643. received_completion_type,
  1644. generator.add_constant(Value(to_underlying(Completion::Type::Normal))));
  1645. generator.emit_jump_if(
  1646. received_completion_type_register_is_normal,
  1647. Bytecode::Label { type_is_normal_block },
  1648. Bytecode::Label { is_type_throw_block });
  1649. generator.switch_to_basic_block(type_is_normal_block);
  1650. // i. Let innerResult be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]], « received.[[Value]] »).
  1651. auto array = generator.allocate_register();
  1652. generator.emit_with_extra_operand_slots<Bytecode::Op::NewArray>(1, array, ReadonlySpan<ScopedOperand> { &received_completion_value, 1 });
  1653. auto inner_result = generator.allocate_register();
  1654. generator.emit<Bytecode::Op::CallWithArgumentArray>(Bytecode::Op::CallType::Call, inner_result, next_method, iterator, array);
  1655. // ii. If generatorKind is async, set innerResult to ? Await(innerResult).
  1656. if (generator.is_in_async_generator_function()) {
  1657. auto new_inner_result = generate_await(generator, inner_result, received_completion, received_completion_type, received_completion_value, type_identifier, value_identifier);
  1658. generator.emit<Bytecode::Op::Mov>(inner_result, new_inner_result);
  1659. }
  1660. // iii. If innerResult is not an Object, throw a TypeError exception.
  1661. generator.emit<Bytecode::Op::ThrowIfNotObject>(inner_result);
  1662. // iv. Let done be ? IteratorComplete(innerResult).
  1663. auto done = generator.allocate_register();
  1664. generator.emit_iterator_complete(done, inner_result);
  1665. // v. If done is true, then
  1666. auto& type_is_normal_done_block = generator.make_block();
  1667. auto& type_is_normal_not_done_block = generator.make_block();
  1668. generator.emit_jump_if(
  1669. done,
  1670. Bytecode::Label { type_is_normal_done_block },
  1671. Bytecode::Label { type_is_normal_not_done_block });
  1672. generator.switch_to_basic_block(type_is_normal_done_block);
  1673. // 1. Return ? IteratorValue(innerResult).
  1674. auto return_value = generator.allocate_register();
  1675. generator.emit_iterator_value(return_value, inner_result);
  1676. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { loop_end_block });
  1677. generator.switch_to_basic_block(type_is_normal_not_done_block);
  1678. // vi. If generatorKind is async, set received to Completion(AsyncGeneratorYield(? IteratorValue(innerResult))).
  1679. // vii. Else, set received to Completion(GeneratorYield(innerResult)).
  1680. {
  1681. // FIXME: Yield currently only accepts a Value, not an object conforming to the IteratorResult interface, so we have to do an observable lookup of `value` here.
  1682. // This only matters for non-async generators.
  1683. auto current_value = generator.allocate_register();
  1684. generator.emit_iterator_value(current_value, inner_result);
  1685. if (is_in_finalizer) {
  1686. saved_exception = generator.allocate_register();
  1687. generator.emit<Bytecode::Op::Mov>(Bytecode::Operand(*saved_exception), Bytecode::Operand(Bytecode::Register::exception()));
  1688. }
  1689. generate_yield(generator,
  1690. Bytecode::Label { continuation_block },
  1691. current_value,
  1692. received_completion,
  1693. received_completion_type,
  1694. received_completion_value,
  1695. type_identifier,
  1696. value_identifier,
  1697. AwaitBeforeYield::No);
  1698. }
  1699. // b. Else if received.[[Type]] is throw, then
  1700. generator.switch_to_basic_block(is_type_throw_block);
  1701. auto& type_is_throw_block = generator.make_block();
  1702. auto& type_is_return_block = generator.make_block();
  1703. auto received_completion_type_register_is_throw = generator.allocate_register();
  1704. generator.emit<Bytecode::Op::StrictlyEquals>(
  1705. received_completion_type_register_is_throw,
  1706. received_completion_type,
  1707. generator.add_constant(Value(to_underlying(Completion::Type::Throw))));
  1708. generator.emit_jump_if(
  1709. received_completion_type_register_is_throw,
  1710. Bytecode::Label { type_is_throw_block },
  1711. Bytecode::Label { type_is_return_block });
  1712. generator.switch_to_basic_block(type_is_throw_block);
  1713. // i. Let throw be ? GetMethod(iterator, "throw").
  1714. auto throw_method = generator.allocate_register();
  1715. generator.emit<Bytecode::Op::GetMethod>(throw_method, iterator, generator.intern_identifier("throw"));
  1716. // ii. If throw is not undefined, then
  1717. auto& throw_method_is_defined_block = generator.make_block();
  1718. auto& throw_method_is_undefined_block = generator.make_block();
  1719. generator.emit<Bytecode::Op::JumpUndefined>(
  1720. throw_method,
  1721. Bytecode::Label { throw_method_is_undefined_block },
  1722. Bytecode::Label { throw_method_is_defined_block });
  1723. generator.switch_to_basic_block(throw_method_is_defined_block);
  1724. // 1. Let innerResult be ? Call(throw, iterator, « received.[[Value]] »).
  1725. auto received_value_array = generator.allocate_register();
  1726. generator.emit_with_extra_operand_slots<Bytecode::Op::NewArray>(1, received_value_array, ReadonlySpan<ScopedOperand> { &received_completion_value, 1 });
  1727. generator.emit<Bytecode::Op::CallWithArgumentArray>(Bytecode::Op::CallType::Call, inner_result, throw_method, iterator, received_value_array);
  1728. // 2. If generatorKind is async, set innerResult to ? Await(innerResult).
  1729. if (generator.is_in_async_generator_function()) {
  1730. auto new_result = generate_await(generator, inner_result, received_completion, received_completion_type, received_completion_value, type_identifier, value_identifier);
  1731. generator.emit<Bytecode::Op::Mov>(inner_result, new_result);
  1732. }
  1733. // 3. NOTE: Exceptions from the inner iterator throw method are propagated. Normal completions from an inner throw method are processed similarly to an inner next.
  1734. // 4. If innerResult is not an Object, throw a TypeError exception.
  1735. generator.emit<Bytecode::Op::ThrowIfNotObject>(inner_result);
  1736. // 5. Let done be ? IteratorComplete(innerResult).
  1737. generator.emit_iterator_complete(done, inner_result);
  1738. // 6. If done is true, then
  1739. auto& type_is_throw_done_block = generator.make_block();
  1740. auto& type_is_throw_not_done_block = generator.make_block();
  1741. generator.emit_jump_if(
  1742. done,
  1743. Bytecode::Label { type_is_throw_done_block },
  1744. Bytecode::Label { type_is_throw_not_done_block });
  1745. generator.switch_to_basic_block(type_is_throw_done_block);
  1746. // a. Return ? IteratorValue(innerResult).
  1747. generator.emit_iterator_value(return_value, inner_result);
  1748. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { loop_end_block });
  1749. generator.switch_to_basic_block(type_is_throw_not_done_block);
  1750. {
  1751. // 7. If generatorKind is async, set received to Completion(AsyncGeneratorYield(? IteratorValue(innerResult))).
  1752. // 8. Else, set received to Completion(GeneratorYield(innerResult)).
  1753. // FIXME: Yield currently only accepts a Value, not an object conforming to the IteratorResult interface, so we have to do an observable lookup of `value` here.
  1754. // This only matters for non-async generators.
  1755. auto yield_value = generator.allocate_register();
  1756. generator.emit_iterator_value(yield_value, inner_result);
  1757. generate_yield(generator, Bytecode::Label { continuation_block }, yield_value, received_completion, received_completion_type, received_completion_value, type_identifier, value_identifier, AwaitBeforeYield::No);
  1758. }
  1759. generator.switch_to_basic_block(throw_method_is_undefined_block);
  1760. // 1. NOTE: If iterator does not have a throw method, this throw is going to terminate the yield* loop. But first we need to give iterator a chance to clean up.
  1761. // 2. Let closeCompletion be Completion Record { [[Type]]: normal, [[Value]]: empty, [[Target]]: empty }.
  1762. // 3. If generatorKind is async, perform ? AsyncIteratorClose(iteratorRecord, closeCompletion).
  1763. if (generator.is_in_async_generator_function()) {
  1764. // FIXME: This performs `await` outside of the generator!
  1765. generator.emit<Bytecode::Op::AsyncIteratorClose>(iterator_record, Completion::Type::Normal, Optional<Value> {});
  1766. }
  1767. // 4. Else, perform ? IteratorClose(iteratorRecord, closeCompletion).
  1768. else {
  1769. generator.emit<Bytecode::Op::IteratorClose>(iterator_record, Completion::Type::Normal, Optional<Value> {});
  1770. }
  1771. // 5. NOTE: The next step throws a TypeError to indicate that there was a yield* protocol violation: iterator does not have a throw method.
  1772. // 6. Throw a TypeError exception.
  1773. auto exception = generator.allocate_register();
  1774. generator.emit<Bytecode::Op::NewTypeError>(exception, generator.intern_string(ErrorType::YieldFromIteratorMissingThrowMethod.message()));
  1775. generator.perform_needed_unwinds<Bytecode::Op::Throw>();
  1776. generator.emit<Bytecode::Op::Throw>(exception);
  1777. // c. Else,
  1778. // i. Assert: received.[[Type]] is return.
  1779. generator.switch_to_basic_block(type_is_return_block);
  1780. // ii. Let return be ? GetMethod(iterator, "return").
  1781. auto return_method = generator.allocate_register();
  1782. generator.emit<Bytecode::Op::GetMethod>(return_method, iterator, generator.intern_identifier("return"));
  1783. // iii. If return is undefined, then
  1784. auto& return_is_undefined_block = generator.make_block();
  1785. auto& return_is_defined_block = generator.make_block();
  1786. generator.emit<Bytecode::Op::JumpUndefined>(
  1787. return_method,
  1788. Bytecode::Label { return_is_undefined_block },
  1789. Bytecode::Label { return_is_defined_block });
  1790. generator.switch_to_basic_block(return_is_undefined_block);
  1791. // 1. If generatorKind is async, set received.[[Value]] to ? Await(received.[[Value]]).
  1792. if (generator.is_in_async_generator_function()) {
  1793. generate_await(generator, received_completion_value, received_completion, received_completion_type, received_completion_value, type_identifier, value_identifier);
  1794. }
  1795. // 2. Return ? received.
  1796. // NOTE: This will always be a return completion.
  1797. generator.emit_return<Bytecode::Op::Yield>(received_completion_value);
  1798. generator.switch_to_basic_block(return_is_defined_block);
  1799. // iv. Let innerReturnResult be ? Call(return, iterator, « received.[[Value]] »).
  1800. auto call_array = generator.allocate_register();
  1801. generator.emit_with_extra_operand_slots<Bytecode::Op::NewArray>(1, call_array, ReadonlySpan<ScopedOperand> { &received_completion_value, 1 });
  1802. auto inner_return_result = generator.allocate_register();
  1803. generator.emit<Bytecode::Op::CallWithArgumentArray>(Bytecode::Op::CallType::Call, inner_return_result, return_method, iterator, call_array);
  1804. // v. If generatorKind is async, set innerReturnResult to ? Await(innerReturnResult).
  1805. if (generator.is_in_async_generator_function()) {
  1806. auto new_value = generate_await(generator, inner_return_result, received_completion, received_completion_type, received_completion_value, type_identifier, value_identifier);
  1807. generator.emit<Bytecode::Op::Mov>(inner_return_result, new_value);
  1808. }
  1809. // vi. If innerReturnResult is not an Object, throw a TypeError exception.
  1810. generator.emit<Bytecode::Op::ThrowIfNotObject>(inner_return_result);
  1811. // vii. Let done be ? IteratorComplete(innerReturnResult).
  1812. generator.emit_iterator_complete(done, inner_return_result);
  1813. // viii. If done is true, then
  1814. auto& type_is_return_done_block = generator.make_block();
  1815. auto& type_is_return_not_done_block = generator.make_block();
  1816. generator.emit_jump_if(
  1817. done,
  1818. Bytecode::Label { type_is_return_done_block },
  1819. Bytecode::Label { type_is_return_not_done_block });
  1820. generator.switch_to_basic_block(type_is_return_done_block);
  1821. // 1. Let value be ? IteratorValue(innerReturnResult).
  1822. auto inner_return_result_value = generator.allocate_register();
  1823. generator.emit_iterator_value(inner_return_result_value, inner_return_result);
  1824. // 2. Return Completion Record { [[Type]]: return, [[Value]]: value, [[Target]]: empty }.
  1825. generator.emit_return<Bytecode::Op::Yield>(inner_return_result_value);
  1826. generator.switch_to_basic_block(type_is_return_not_done_block);
  1827. // ix. If generatorKind is async, set received to Completion(AsyncGeneratorYield(? IteratorValue(innerReturnResult))).
  1828. // x. Else, set received to Completion(GeneratorYield(innerReturnResult)).
  1829. // FIXME: Yield currently only accepts a Value, not an object conforming to the IteratorResult interface, so we have to do an observable lookup of `value` here.
  1830. // This only matters for non-async generators.
  1831. auto received = generator.allocate_register();
  1832. generator.emit_iterator_value(received, inner_return_result);
  1833. generate_yield(generator, Bytecode::Label { continuation_block }, received, received_completion, received_completion_type, received_completion_value, type_identifier, value_identifier, AwaitBeforeYield::No);
  1834. generator.switch_to_basic_block(continuation_block);
  1835. if (is_in_finalizer)
  1836. generator.emit<Bytecode::Op::Mov>(Bytecode::Operand(Bytecode::Register::exception()), Bytecode::Operand(*saved_exception));
  1837. generator.emit<Bytecode::Op::Mov>(received_completion, generator.accumulator());
  1838. get_received_completion_type_and_value(generator, received_completion, received_completion_type, received_completion_value, type_identifier, value_identifier);
  1839. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { loop_block });
  1840. generator.switch_to_basic_block(loop_end_block);
  1841. return return_value;
  1842. }
  1843. Optional<ScopedOperand> argument;
  1844. if (m_argument)
  1845. argument = TRY(m_argument->generate_bytecode(generator)).value();
  1846. else
  1847. argument = generator.add_constant(js_undefined());
  1848. auto& continuation_block = generator.make_block();
  1849. if (is_in_finalizer) {
  1850. saved_exception = generator.allocate_register();
  1851. generator.emit<Bytecode::Op::Mov>(Bytecode::Operand(*saved_exception), Bytecode::Operand(Bytecode::Register::exception()));
  1852. }
  1853. generate_yield(generator, Bytecode::Label { continuation_block }, *argument, received_completion, received_completion_type, received_completion_value, type_identifier, value_identifier, AwaitBeforeYield::Yes);
  1854. generator.switch_to_basic_block(continuation_block);
  1855. if (is_in_finalizer)
  1856. generator.emit<Bytecode::Op::Mov>(Bytecode::Operand(Bytecode::Register::exception()), Bytecode::Operand(*saved_exception));
  1857. generator.emit<Bytecode::Op::Mov>(received_completion, generator.accumulator());
  1858. get_received_completion_type_and_value(generator, received_completion, received_completion_type, received_completion_value, type_identifier, value_identifier);
  1859. auto& normal_completion_continuation_block = generator.make_block();
  1860. auto& throw_completion_continuation_block = generator.make_block();
  1861. auto received_completion_type_is_normal = generator.allocate_register();
  1862. generator.emit<Bytecode::Op::StrictlyEquals>(
  1863. received_completion_type_is_normal,
  1864. received_completion_type,
  1865. generator.add_constant(Value(to_underlying(Completion::Type::Normal))));
  1866. generator.emit_jump_if(
  1867. received_completion_type_is_normal,
  1868. Bytecode::Label { normal_completion_continuation_block },
  1869. Bytecode::Label { throw_completion_continuation_block });
  1870. auto& throw_value_block = generator.make_block();
  1871. auto& return_value_block = generator.make_block();
  1872. generator.switch_to_basic_block(throw_completion_continuation_block);
  1873. auto received_completion_type_is_throw = generator.allocate_register();
  1874. generator.emit<Bytecode::Op::StrictlyEquals>(
  1875. received_completion_type_is_throw,
  1876. received_completion_type,
  1877. generator.add_constant(Value(to_underlying(Completion::Type::Throw))));
  1878. // If type is not equal to "throw" or "normal", assume it's "return".
  1879. generator.emit_jump_if(
  1880. received_completion_type_is_throw,
  1881. Bytecode::Label { throw_value_block },
  1882. Bytecode::Label { return_value_block });
  1883. generator.switch_to_basic_block(throw_value_block);
  1884. generator.perform_needed_unwinds<Bytecode::Op::Throw>();
  1885. generator.emit<Bytecode::Op::Throw>(received_completion_value);
  1886. generator.switch_to_basic_block(return_value_block);
  1887. generator.emit_return<Bytecode::Op::Yield>(received_completion_value);
  1888. generator.switch_to_basic_block(normal_completion_continuation_block);
  1889. return received_completion_value;
  1890. }
  1891. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> IfStatement::generate_bytecode(Bytecode::Generator& generator, Optional<ScopedOperand> preferred_dst) const
  1892. {
  1893. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  1894. // test
  1895. // jump if_true (true) true (false) false
  1896. // true
  1897. // jump always (true) end
  1898. // false
  1899. // jump always (true) end
  1900. // end
  1901. auto& true_block = generator.make_block();
  1902. auto& false_block = generator.make_block();
  1903. auto& end_block = generator.make_block();
  1904. Optional<ScopedOperand> completion;
  1905. if (generator.must_propagate_completion()) {
  1906. completion = choose_dst(generator, preferred_dst);
  1907. generator.emit<Bytecode::Op::Mov>(*completion, generator.add_constant(js_undefined()));
  1908. }
  1909. auto predicate = TRY(m_predicate->generate_bytecode(generator)).value();
  1910. generator.emit_jump_if(
  1911. predicate,
  1912. Bytecode::Label { true_block },
  1913. Bytecode::Label { false_block });
  1914. generator.switch_to_basic_block(true_block);
  1915. auto consequent = TRY(m_consequent->generate_bytecode(generator, completion));
  1916. if (!generator.is_current_block_terminated()) {
  1917. if (generator.must_propagate_completion()) {
  1918. if (consequent.has_value())
  1919. generator.emit<Bytecode::Op::Mov>(*completion, *consequent);
  1920. }
  1921. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { end_block });
  1922. }
  1923. generator.switch_to_basic_block(false_block);
  1924. Optional<ScopedOperand> alternate;
  1925. if (m_alternate) {
  1926. alternate = TRY(m_alternate->generate_bytecode(generator, completion));
  1927. }
  1928. if (!generator.is_current_block_terminated()) {
  1929. if (generator.must_propagate_completion()) {
  1930. if (alternate.has_value())
  1931. generator.emit<Bytecode::Op::Mov>(*completion, *alternate);
  1932. }
  1933. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { end_block });
  1934. }
  1935. generator.switch_to_basic_block(end_block);
  1936. return completion;
  1937. }
  1938. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ContinueStatement::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  1939. {
  1940. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  1941. if (!m_target_label.has_value()) {
  1942. generator.generate_continue();
  1943. return Optional<ScopedOperand> {};
  1944. }
  1945. generator.generate_continue(m_target_label.value());
  1946. return Optional<ScopedOperand> {};
  1947. }
  1948. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> DebuggerStatement::generate_bytecode(Bytecode::Generator&, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  1949. {
  1950. return Optional<ScopedOperand> {};
  1951. }
  1952. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ConditionalExpression::generate_bytecode(Bytecode::Generator& generator, Optional<ScopedOperand> preferred_dst) const
  1953. {
  1954. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  1955. // test
  1956. // jump if_true (true) true (false) false
  1957. // true
  1958. // jump always (true) end
  1959. // false
  1960. // jump always (true) end
  1961. // end
  1962. auto& true_block = generator.make_block();
  1963. auto& false_block = generator.make_block();
  1964. auto& end_block = generator.make_block();
  1965. auto test = TRY(m_test->generate_bytecode(generator)).value();
  1966. generator.emit_jump_if(
  1967. test,
  1968. Bytecode::Label { true_block },
  1969. Bytecode::Label { false_block });
  1970. auto dst = choose_dst(generator, preferred_dst);
  1971. generator.switch_to_basic_block(true_block);
  1972. auto consequent = TRY(m_consequent->generate_bytecode(generator)).value();
  1973. generator.emit<Bytecode::Op::Mov>(dst, consequent);
  1974. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { end_block });
  1975. generator.switch_to_basic_block(false_block);
  1976. auto alternate = TRY(m_alternate->generate_bytecode(generator)).value();
  1977. generator.emit<Bytecode::Op::Mov>(dst, alternate);
  1978. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { end_block });
  1979. generator.switch_to_basic_block(end_block);
  1980. return dst;
  1981. }
  1982. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> SequenceExpression::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  1983. {
  1984. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  1985. Optional<ScopedOperand> last_value;
  1986. for (auto& expression : m_expressions) {
  1987. last_value = TRY(expression->generate_bytecode(generator));
  1988. }
  1989. return last_value;
  1990. }
  1991. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> TemplateLiteral::generate_bytecode(Bytecode::Generator& generator, Optional<ScopedOperand> preferred_dst) const
  1992. {
  1993. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  1994. auto dst = choose_dst(generator, preferred_dst);
  1995. for (size_t i = 0; i < m_expressions.size(); i++) {
  1996. auto value = TRY(m_expressions[i]->generate_bytecode(generator)).value();
  1997. if (i == 0) {
  1998. generator.emit<Bytecode::Op::Mov>(dst, value);
  1999. } else {
  2000. generator.emit<Bytecode::Op::ConcatString>(dst, value);
  2001. }
  2002. }
  2003. return dst;
  2004. }
  2005. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> TaggedTemplateLiteral::generate_bytecode(Bytecode::Generator& generator, Optional<ScopedOperand> preferred_dst) const
  2006. {
  2007. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  2008. auto tag = TRY(m_tag->generate_bytecode(generator)).value();
  2009. // FIXME: Follow
  2010. // 13.2.8.3 GetTemplateObject ( templateLiteral ), https://tc39.es/ecma262/#sec-gettemplateobject
  2011. // more closely, namely:
  2012. // * cache this somehow
  2013. // * add a raw object accessor
  2014. // * freeze array and raw member
  2015. Vector<ScopedOperand> string_regs;
  2016. auto& expressions = m_template_literal->expressions();
  2017. for (size_t i = 0; i < expressions.size(); ++i) {
  2018. if (i % 2 != 0)
  2019. continue;
  2020. // NOTE: If the string contains invalid escapes we get a null expression here,
  2021. // which we then convert to the expected `undefined` TV. See
  2022. // 12.9.6.1 Static Semantics: TV, https://tc39.es/ecma262/#sec-static-semantics-tv
  2023. auto string_reg = generator.allocate_register();
  2024. if (is<NullLiteral>(expressions[i])) {
  2025. generator.emit<Bytecode::Op::Mov>(string_reg, generator.add_constant(js_undefined()));
  2026. } else {
  2027. auto value = TRY(expressions[i]->generate_bytecode(generator)).value();
  2028. generator.emit<Bytecode::Op::Mov>(string_reg, value);
  2029. }
  2030. string_regs.append(move(string_reg));
  2031. }
  2032. auto strings_array = generator.allocate_register();
  2033. if (string_regs.is_empty()) {
  2034. generator.emit<Bytecode::Op::NewArray>(strings_array);
  2035. } else {
  2036. generator.emit_with_extra_operand_slots<Bytecode::Op::NewArray>(string_regs.size(), strings_array, string_regs);
  2037. }
  2038. Vector<ScopedOperand> argument_regs;
  2039. argument_regs.append(strings_array);
  2040. for (size_t i = 1; i < expressions.size(); i += 2) {
  2041. auto string_reg = generator.allocate_register();
  2042. auto string = TRY(expressions[i]->generate_bytecode(generator)).value();
  2043. generator.emit<Bytecode::Op::Mov>(string_reg, string);
  2044. argument_regs.append(move(string_reg));
  2045. }
  2046. Vector<ScopedOperand> raw_string_regs;
  2047. raw_string_regs.ensure_capacity(m_template_literal->raw_strings().size());
  2048. for (auto& raw_string : m_template_literal->raw_strings()) {
  2049. auto value = TRY(raw_string->generate_bytecode(generator)).value();
  2050. auto raw_string_reg = generator.allocate_register();
  2051. generator.emit<Bytecode::Op::Mov>(raw_string_reg, value);
  2052. raw_string_regs.append(move(raw_string_reg));
  2053. }
  2054. auto raw_strings_array = generator.allocate_register();
  2055. if (raw_string_regs.is_empty()) {
  2056. generator.emit<Bytecode::Op::NewArray>(raw_strings_array);
  2057. } else {
  2058. generator.emit_with_extra_operand_slots<Bytecode::Op::NewArray>(raw_string_regs.size(), raw_strings_array, raw_string_regs);
  2059. }
  2060. generator.emit<Bytecode::Op::PutById>(strings_array, generator.intern_identifier("raw"), raw_strings_array, Bytecode::Op::PropertyKind::KeyValue, generator.next_property_lookup_cache());
  2061. auto arguments = generator.allocate_register();
  2062. if (!argument_regs.is_empty())
  2063. generator.emit_with_extra_operand_slots<Bytecode::Op::NewArray>(argument_regs.size(), arguments, argument_regs);
  2064. else
  2065. generator.emit<Bytecode::Op::NewArray>(arguments);
  2066. auto dst = choose_dst(generator, preferred_dst);
  2067. generator.emit<Bytecode::Op::CallWithArgumentArray>(Bytecode::Op::CallType::Call, dst, tag, generator.add_constant(js_undefined()), arguments);
  2068. return dst;
  2069. }
  2070. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> UpdateExpression::generate_bytecode(Bytecode::Generator& generator, Optional<ScopedOperand>) const
  2071. {
  2072. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  2073. auto reference = TRY(generator.emit_load_from_reference(*m_argument));
  2074. Optional<ScopedOperand> previous_value_for_postfix;
  2075. if (m_op == UpdateOp::Increment) {
  2076. if (m_prefixed) {
  2077. generator.emit<Bytecode::Op::Increment>(*reference.loaded_value);
  2078. } else {
  2079. previous_value_for_postfix = generator.allocate_register();
  2080. generator.emit<Bytecode::Op::PostfixIncrement>(*previous_value_for_postfix, *reference.loaded_value);
  2081. }
  2082. } else {
  2083. if (m_prefixed) {
  2084. generator.emit<Bytecode::Op::Decrement>(*reference.loaded_value);
  2085. } else {
  2086. previous_value_for_postfix = generator.allocate_register();
  2087. generator.emit<Bytecode::Op::PostfixDecrement>(*previous_value_for_postfix, *reference.loaded_value);
  2088. }
  2089. }
  2090. if (is<Identifier>(*m_argument))
  2091. (void)TRY(generator.emit_store_to_reference(static_cast<Identifier const&>(*m_argument), *reference.loaded_value));
  2092. else
  2093. (void)TRY(generator.emit_store_to_reference(reference, *reference.loaded_value));
  2094. if (!m_prefixed)
  2095. return *previous_value_for_postfix;
  2096. return *reference.loaded_value;
  2097. }
  2098. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ThrowStatement::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  2099. {
  2100. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  2101. auto argument = TRY(m_argument->generate_bytecode(generator)).value();
  2102. generator.perform_needed_unwinds<Bytecode::Op::Throw>();
  2103. generator.emit<Bytecode::Op::Throw>(argument);
  2104. return Optional<ScopedOperand> {};
  2105. }
  2106. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> BreakStatement::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  2107. {
  2108. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  2109. // FIXME: Handle finally blocks in a graceful manner
  2110. // We need to execute the finally block, but tell it to resume
  2111. // execution at the designated block
  2112. if (!m_target_label.has_value()) {
  2113. generator.generate_break();
  2114. return Optional<ScopedOperand> {};
  2115. }
  2116. generator.generate_break(m_target_label.value());
  2117. return Optional<ScopedOperand> {};
  2118. }
  2119. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> TryStatement::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  2120. {
  2121. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  2122. auto& saved_block = generator.current_block();
  2123. Optional<Bytecode::Label> handler_target;
  2124. Optional<Bytecode::Label> finalizer_target;
  2125. Optional<Bytecode::Generator::UnwindContext> unwind_context;
  2126. Bytecode::BasicBlock* next_block { nullptr };
  2127. Optional<ScopedOperand> completion;
  2128. if (m_finalizer) {
  2129. // FIXME: See notes in Op.h->ScheduleJump
  2130. auto& finalizer_block = generator.make_block();
  2131. generator.switch_to_basic_block(finalizer_block);
  2132. generator.emit<Bytecode::Op::LeaveUnwindContext>();
  2133. generator.start_boundary(Bytecode::Generator::BlockBoundaryType::LeaveFinally);
  2134. (void)TRY(m_finalizer->generate_bytecode(generator));
  2135. generator.end_boundary(Bytecode::Generator::BlockBoundaryType::LeaveFinally);
  2136. if (!generator.is_current_block_terminated()) {
  2137. next_block = &generator.make_block();
  2138. auto next_target = Bytecode::Label { *next_block };
  2139. generator.emit<Bytecode::Op::ContinuePendingUnwind>(next_target);
  2140. }
  2141. finalizer_target = Bytecode::Label { finalizer_block };
  2142. generator.start_boundary(Bytecode::Generator::BlockBoundaryType::ReturnToFinally);
  2143. unwind_context.emplace(generator, finalizer_target);
  2144. }
  2145. if (m_handler) {
  2146. auto& handler_block = generator.make_block();
  2147. generator.switch_to_basic_block(handler_block);
  2148. auto caught_value = generator.allocate_register();
  2149. generator.emit<Bytecode::Op::Catch>(caught_value);
  2150. if (!m_finalizer) {
  2151. generator.emit<Bytecode::Op::LeaveUnwindContext>();
  2152. generator.emit<Bytecode::Op::RestoreScheduledJump>();
  2153. }
  2154. // OPTIMIZATION: We avoid creating a lexical environment if the catch clause has no parameter.
  2155. bool did_create_variable_scope_for_catch_clause = false;
  2156. TRY(m_handler->parameter().visit(
  2157. [&](DeprecatedFlyString const& parameter) -> Bytecode::CodeGenerationErrorOr<void> {
  2158. if (!parameter.is_empty()) {
  2159. generator.begin_variable_scope();
  2160. did_create_variable_scope_for_catch_clause = true;
  2161. auto parameter_identifier = generator.intern_identifier(parameter);
  2162. generator.emit<Bytecode::Op::CreateVariable>(parameter_identifier, Bytecode::Op::EnvironmentMode::Lexical, false);
  2163. generator.emit<Bytecode::Op::InitializeLexicalBinding>(parameter_identifier, caught_value);
  2164. }
  2165. return {};
  2166. },
  2167. [&](NonnullRefPtr<BindingPattern const> const& binding_pattern) -> Bytecode::CodeGenerationErrorOr<void> {
  2168. generator.begin_variable_scope();
  2169. did_create_variable_scope_for_catch_clause = true;
  2170. TRY(binding_pattern->generate_bytecode(generator, Bytecode::Op::BindingInitializationMode::Initialize, caught_value, true));
  2171. return {};
  2172. }));
  2173. auto handler_result = TRY(m_handler->body().generate_bytecode(generator));
  2174. if (generator.must_propagate_completion()) {
  2175. if (handler_result.has_value() && !generator.is_current_block_terminated()) {
  2176. completion = generator.allocate_register();
  2177. generator.emit<Bytecode::Op::Mov>(*completion, *handler_result);
  2178. }
  2179. }
  2180. handler_target = Bytecode::Label { handler_block };
  2181. if (did_create_variable_scope_for_catch_clause)
  2182. generator.end_variable_scope();
  2183. if (!generator.is_current_block_terminated()) {
  2184. if (m_finalizer) {
  2185. generator.emit<Bytecode::Op::Jump>(*finalizer_target);
  2186. } else {
  2187. VERIFY(!next_block);
  2188. VERIFY(!unwind_context.has_value());
  2189. next_block = &generator.make_block();
  2190. auto next_target = Bytecode::Label { *next_block };
  2191. generator.emit<Bytecode::Op::Jump>(next_target);
  2192. }
  2193. }
  2194. }
  2195. if (m_finalizer)
  2196. generator.end_boundary(Bytecode::Generator::BlockBoundaryType::ReturnToFinally);
  2197. if (m_handler) {
  2198. if (!m_finalizer) {
  2199. auto const* parent_unwind_context = generator.current_unwind_context();
  2200. if (parent_unwind_context)
  2201. unwind_context.emplace(generator, parent_unwind_context->finalizer());
  2202. else
  2203. unwind_context.emplace(generator, OptionalNone());
  2204. }
  2205. unwind_context->set_handler(handler_target.value());
  2206. }
  2207. auto& target_block = generator.make_block();
  2208. generator.switch_to_basic_block(saved_block);
  2209. generator.emit<Bytecode::Op::EnterUnwindContext>(Bytecode::Label { target_block });
  2210. generator.start_boundary(Bytecode::Generator::BlockBoundaryType::Unwind);
  2211. if (m_finalizer)
  2212. generator.start_boundary(Bytecode::Generator::BlockBoundaryType::ReturnToFinally);
  2213. generator.switch_to_basic_block(target_block);
  2214. auto block_result = TRY(m_block->generate_bytecode(generator));
  2215. if (!generator.is_current_block_terminated()) {
  2216. if (generator.must_propagate_completion()) {
  2217. if (block_result.has_value()) {
  2218. completion = generator.allocate_register();
  2219. generator.emit<Bytecode::Op::Mov>(*completion, *block_result);
  2220. }
  2221. }
  2222. if (m_finalizer) {
  2223. generator.emit<Bytecode::Op::Jump>(*finalizer_target);
  2224. } else {
  2225. VERIFY(unwind_context.has_value());
  2226. unwind_context.clear();
  2227. if (!next_block)
  2228. next_block = &generator.make_block();
  2229. generator.emit<Bytecode::Op::LeaveUnwindContext>();
  2230. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { *next_block });
  2231. }
  2232. }
  2233. if (m_finalizer)
  2234. generator.end_boundary(Bytecode::Generator::BlockBoundaryType::ReturnToFinally);
  2235. generator.end_boundary(Bytecode::Generator::BlockBoundaryType::Unwind);
  2236. generator.switch_to_basic_block(next_block ? *next_block : saved_block);
  2237. if (generator.must_propagate_completion()) {
  2238. if (!completion.has_value())
  2239. return generator.add_constant(js_undefined());
  2240. }
  2241. return completion;
  2242. }
  2243. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> SwitchStatement::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  2244. {
  2245. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  2246. return generate_labelled_evaluation(generator, {});
  2247. }
  2248. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> SwitchStatement::generate_labelled_evaluation(Bytecode::Generator& generator, Vector<DeprecatedFlyString> const& label_set, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  2249. {
  2250. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  2251. Optional<ScopedOperand> completion;
  2252. if (generator.must_propagate_completion()) {
  2253. completion = generator.allocate_register();
  2254. generator.emit<Bytecode::Op::Mov>(*completion, generator.add_constant(js_undefined()));
  2255. }
  2256. auto discriminant = TRY(m_discriminant->generate_bytecode(generator)).value();
  2257. Vector<Bytecode::BasicBlock&> case_blocks;
  2258. Bytecode::BasicBlock* entry_block_for_default { nullptr };
  2259. Bytecode::BasicBlock* next_test_block = &generator.make_block();
  2260. bool did_create_lexical_environment = false;
  2261. if (has_lexical_declarations())
  2262. did_create_lexical_environment = generator.emit_block_declaration_instantiation(*this);
  2263. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { *next_test_block });
  2264. Queue<Bytecode::BasicBlock*> test_blocks;
  2265. for (auto& switch_case : m_cases) {
  2266. if (switch_case->test())
  2267. test_blocks.enqueue(&generator.make_block());
  2268. }
  2269. for (auto& switch_case : m_cases) {
  2270. auto& case_block = generator.make_block();
  2271. if (switch_case->test()) {
  2272. generator.switch_to_basic_block(*next_test_block);
  2273. auto test_value = TRY(switch_case->test()->generate_bytecode(generator)).value();
  2274. auto result = generator.allocate_register();
  2275. generator.emit<Bytecode::Op::StrictlyEquals>(result, test_value, discriminant);
  2276. next_test_block = test_blocks.dequeue();
  2277. generator.emit_jump_if(
  2278. result,
  2279. Bytecode::Label { case_block },
  2280. Bytecode::Label { *next_test_block });
  2281. } else {
  2282. entry_block_for_default = &case_block;
  2283. }
  2284. case_blocks.append(case_block);
  2285. }
  2286. generator.switch_to_basic_block(*next_test_block);
  2287. auto& end_block = generator.make_block();
  2288. if (entry_block_for_default != nullptr) {
  2289. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { *entry_block_for_default });
  2290. } else {
  2291. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { end_block });
  2292. }
  2293. auto current_block = case_blocks.begin();
  2294. generator.begin_breakable_scope(Bytecode::Label { end_block }, label_set);
  2295. for (auto& switch_case : m_cases) {
  2296. generator.switch_to_basic_block(*current_block);
  2297. for (auto& statement : switch_case->children()) {
  2298. auto result = TRY(statement->generate_bytecode(generator));
  2299. if (generator.is_current_block_terminated())
  2300. break;
  2301. if (generator.must_propagate_completion()) {
  2302. if (result.has_value())
  2303. generator.emit<Bytecode::Op::Mov>(*completion, *result);
  2304. else
  2305. generator.emit<Bytecode::Op::Mov>(*completion, generator.add_constant(js_undefined()));
  2306. }
  2307. }
  2308. if (!generator.is_current_block_terminated()) {
  2309. auto next_block = current_block;
  2310. next_block++;
  2311. if (next_block.is_end()) {
  2312. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { end_block });
  2313. } else {
  2314. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { *next_block });
  2315. }
  2316. }
  2317. current_block++;
  2318. }
  2319. generator.end_breakable_scope();
  2320. generator.switch_to_basic_block(end_block);
  2321. if (did_create_lexical_environment)
  2322. generator.end_variable_scope();
  2323. return completion;
  2324. }
  2325. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> SuperExpression::generate_bytecode(Bytecode::Generator&, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  2326. {
  2327. // The semantics for SuperExpression are handled in CallExpression and SuperCall.
  2328. VERIFY_NOT_REACHED();
  2329. }
  2330. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ClassDeclaration::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  2331. {
  2332. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  2333. auto value = TRY(m_class_expression->generate_bytecode(generator)).value();
  2334. generator.emit_set_variable(*m_class_expression.ptr()->m_name, value, Bytecode::Op::BindingInitializationMode::Initialize);
  2335. // NOTE: ClassDeclaration does not produce a value.
  2336. return Optional<ScopedOperand> {};
  2337. }
  2338. // 15.7.14 Runtime Semantics: ClassDefinitionEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-classdefinitionevaluation
  2339. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ClassExpression::generate_bytecode_with_lhs_name(Bytecode::Generator& generator, Optional<Bytecode::IdentifierTableIndex> lhs_name, Optional<ScopedOperand> preferred_dst) const
  2340. {
  2341. // NOTE: Step 2 is not a part of NewClass instruction because it is assumed to be done before super class expression evaluation
  2342. generator.emit<Bytecode::Op::CreateLexicalEnvironment>();
  2343. if (has_name() || !lhs_name.has_value()) {
  2344. // NOTE: Step 3.a is not a part of NewClass instruction because it is assumed to be done before super class expression evaluation
  2345. auto interned_index = generator.intern_identifier(name());
  2346. generator.emit<Bytecode::Op::CreateVariable>(interned_index, Bytecode::Op::EnvironmentMode::Lexical, true);
  2347. }
  2348. Optional<ScopedOperand> super_class;
  2349. if (m_super_class)
  2350. super_class = TRY(m_super_class->generate_bytecode(generator)).value();
  2351. generator.emit<Op::CreatePrivateEnvironment>();
  2352. for (auto const& element : m_elements) {
  2353. auto opt_private_name = element->private_bound_identifier();
  2354. if (opt_private_name.has_value()) {
  2355. generator.emit<Op::AddPrivateName>(generator.intern_identifier(*opt_private_name));
  2356. }
  2357. }
  2358. Vector<Optional<ScopedOperand>> elements;
  2359. for (auto const& element : m_elements) {
  2360. Optional<ScopedOperand> key;
  2361. if (is<ClassMethod>(*element)) {
  2362. auto const& class_method = static_cast<ClassMethod const&>(*element);
  2363. if (!is<PrivateIdentifier>(class_method.key()))
  2364. key = TRY(class_method.key().generate_bytecode(generator));
  2365. } else if (is<ClassField>(*element)) {
  2366. auto const& class_field = static_cast<ClassField const&>(*element);
  2367. if (!is<PrivateIdentifier>(class_field.key()))
  2368. key = TRY(class_field.key().generate_bytecode(generator));
  2369. }
  2370. elements.append({ key });
  2371. }
  2372. auto dst = choose_dst(generator, preferred_dst);
  2373. generator.emit_with_extra_slots<Op::NewClass, Optional<Operand>>(elements.size(), dst, super_class.has_value() ? super_class->operand() : Optional<Operand> {}, *this, lhs_name, elements);
  2374. generator.emit<Op::LeavePrivateEnvironment>();
  2375. return dst;
  2376. }
  2377. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ClassExpression::generate_bytecode(Bytecode::Generator& generator, Optional<ScopedOperand> preferred_dst) const
  2378. {
  2379. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  2380. return generate_bytecode_with_lhs_name(generator, {}, preferred_dst);
  2381. }
  2382. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> SpreadExpression::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  2383. {
  2384. // NOTE: All users of this should handle the behaviour of this on their own,
  2385. // assuming it returns an Array-like object
  2386. return m_target->generate_bytecode(generator);
  2387. }
  2388. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ThisExpression::generate_bytecode(Bytecode::Generator& generator, Optional<ScopedOperand> preferred_dst) const
  2389. {
  2390. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  2391. return generator.get_this(preferred_dst);
  2392. }
  2393. static ScopedOperand generate_await(
  2394. Bytecode::Generator& generator,
  2395. ScopedOperand argument,
  2396. ScopedOperand received_completion,
  2397. ScopedOperand received_completion_type,
  2398. ScopedOperand received_completion_value,
  2399. Bytecode::IdentifierTableIndex type_identifier,
  2400. Bytecode::IdentifierTableIndex value_identifier)
  2401. {
  2402. VERIFY(generator.is_in_async_function());
  2403. auto& continuation_block = generator.make_block();
  2404. generator.emit<Bytecode::Op::Await>(Bytecode::Label { continuation_block }, argument);
  2405. generator.switch_to_basic_block(continuation_block);
  2406. // FIXME: It's really magical that we can just assume that the completion value is in register 0.
  2407. // It ends up there because we "return" from the Await instruction above via the synthetic
  2408. // generator function that actually drives async execution.
  2409. generator.emit<Bytecode::Op::Mov>(received_completion, generator.accumulator());
  2410. get_received_completion_type_and_value(generator, received_completion, received_completion_type, received_completion_value, type_identifier, value_identifier);
  2411. auto& normal_completion_continuation_block = generator.make_block();
  2412. auto& throw_value_block = generator.make_block();
  2413. auto received_completion_type_is_normal = generator.allocate_register();
  2414. generator.emit<Bytecode::Op::StrictlyEquals>(
  2415. received_completion_type_is_normal,
  2416. received_completion_type,
  2417. generator.add_constant(Value(to_underlying(Completion::Type::Normal))));
  2418. generator.emit_jump_if(
  2419. received_completion_type_is_normal,
  2420. Bytecode::Label { normal_completion_continuation_block },
  2421. Bytecode::Label { throw_value_block });
  2422. // Simplification: The only abrupt completion we receive from AsyncFunctionDriverWrapper or AsyncGenerator is Type::Throw
  2423. // So we do not need to account for the Type::Return path
  2424. generator.switch_to_basic_block(throw_value_block);
  2425. generator.perform_needed_unwinds<Bytecode::Op::Throw>();
  2426. generator.emit<Bytecode::Op::Throw>(received_completion_value);
  2427. generator.switch_to_basic_block(normal_completion_continuation_block);
  2428. return received_completion_value;
  2429. }
  2430. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> AwaitExpression::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  2431. {
  2432. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  2433. auto argument = TRY(m_argument->generate_bytecode(generator)).value();
  2434. auto received_completion = generator.allocate_register();
  2435. auto received_completion_type = generator.allocate_register();
  2436. auto received_completion_value = generator.allocate_register();
  2437. generator.emit<Bytecode::Op::Mov>(received_completion, generator.accumulator());
  2438. auto type_identifier = generator.intern_identifier("type");
  2439. auto value_identifier = generator.intern_identifier("value");
  2440. return generate_await(generator, argument, received_completion, received_completion_type, received_completion_value, type_identifier, value_identifier);
  2441. }
  2442. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> WithStatement::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  2443. {
  2444. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  2445. auto object = TRY(m_object->generate_bytecode(generator)).value();
  2446. generator.emit<Bytecode::Op::EnterObjectEnvironment>(object);
  2447. // EnterObjectEnvironment sets the running execution context's lexical_environment to a new Object Environment.
  2448. generator.start_boundary(Bytecode::Generator::BlockBoundaryType::LeaveLexicalEnvironment);
  2449. auto body_result = TRY(m_body->generate_bytecode(generator));
  2450. if (!body_result.has_value())
  2451. body_result = generator.add_constant(js_undefined());
  2452. generator.end_boundary(Bytecode::Generator::BlockBoundaryType::LeaveLexicalEnvironment);
  2453. if (!generator.is_current_block_terminated())
  2454. generator.emit<Bytecode::Op::LeaveLexicalEnvironment>();
  2455. return body_result;
  2456. }
  2457. enum class LHSKind {
  2458. Assignment,
  2459. VarBinding,
  2460. LexicalBinding,
  2461. };
  2462. enum class IterationKind {
  2463. Enumerate,
  2464. Iterate,
  2465. AsyncIterate,
  2466. };
  2467. // 14.7.5.6 ForIn/OfHeadEvaluation ( uninitializedBoundNames, expr, iterationKind ), https://tc39.es/ecma262/#sec-runtime-semantics-forinofheadevaluation
  2468. struct ForInOfHeadEvaluationResult {
  2469. bool is_destructuring { false };
  2470. LHSKind lhs_kind { LHSKind::Assignment };
  2471. Optional<ScopedOperand> iterator;
  2472. };
  2473. static Bytecode::CodeGenerationErrorOr<ForInOfHeadEvaluationResult> for_in_of_head_evaluation(Bytecode::Generator& generator, IterationKind iteration_kind, Variant<NonnullRefPtr<ASTNode const>, NonnullRefPtr<BindingPattern const>> const& lhs, NonnullRefPtr<ASTNode const> const& rhs)
  2474. {
  2475. ForInOfHeadEvaluationResult result {};
  2476. bool entered_lexical_scope = false;
  2477. if (auto* ast_ptr = lhs.get_pointer<NonnullRefPtr<ASTNode const>>(); ast_ptr && is<VariableDeclaration>(**ast_ptr)) {
  2478. // Runtime Semantics: ForInOfLoopEvaluation, for any of:
  2479. // ForInOfStatement : for ( var ForBinding in Expression ) Statement
  2480. // ForInOfStatement : for ( ForDeclaration in Expression ) Statement
  2481. // ForInOfStatement : for ( var ForBinding of AssignmentExpression ) Statement
  2482. // ForInOfStatement : for ( ForDeclaration of AssignmentExpression ) Statement
  2483. auto& variable_declaration = static_cast<VariableDeclaration const&>(**ast_ptr);
  2484. result.is_destructuring = variable_declaration.declarations().first()->target().has<NonnullRefPtr<BindingPattern const>>();
  2485. result.lhs_kind = variable_declaration.is_lexical_declaration() ? LHSKind::LexicalBinding : LHSKind::VarBinding;
  2486. if (variable_declaration.declaration_kind() == DeclarationKind::Var) {
  2487. // B.3.5 Initializers in ForIn Statement Heads, https://tc39.es/ecma262/#sec-initializers-in-forin-statement-heads
  2488. auto& variable = variable_declaration.declarations().first();
  2489. if (variable->init()) {
  2490. VERIFY(variable->target().has<NonnullRefPtr<Identifier const>>());
  2491. auto identifier = variable->target().get<NonnullRefPtr<Identifier const>>();
  2492. auto identifier_table_ref = generator.intern_identifier(identifier->string());
  2493. auto value = TRY(generator.emit_named_evaluation_if_anonymous_function(*variable->init(), identifier_table_ref)).value();
  2494. generator.emit_set_variable(*identifier, value);
  2495. }
  2496. } else {
  2497. auto has_non_local_variables = false;
  2498. MUST(variable_declaration.for_each_bound_identifier([&](auto const& identifier) {
  2499. if (!identifier.is_local())
  2500. has_non_local_variables = true;
  2501. }));
  2502. if (has_non_local_variables) {
  2503. // 1. Let oldEnv be the running execution context's LexicalEnvironment.
  2504. // NOTE: 'uninitializedBoundNames' refers to the lexical bindings (i.e. Const/Let) present in the second and last form.
  2505. // 2. If uninitializedBoundNames is not an empty List, then
  2506. entered_lexical_scope = true;
  2507. // a. Assert: uninitializedBoundNames has no duplicate entries.
  2508. // b. Let newEnv be NewDeclarativeEnvironment(oldEnv).
  2509. generator.begin_variable_scope();
  2510. // c. For each String name of uninitializedBoundNames, do
  2511. // NOTE: Nothing in the callback throws an exception.
  2512. MUST(variable_declaration.for_each_bound_identifier([&](auto const& identifier) {
  2513. if (identifier.is_local())
  2514. return;
  2515. // i. Perform ! newEnv.CreateMutableBinding(name, false).
  2516. auto interned_identifier = generator.intern_identifier(identifier.string());
  2517. generator.emit<Bytecode::Op::CreateVariable>(interned_identifier, Bytecode::Op::EnvironmentMode::Lexical, false);
  2518. }));
  2519. // d. Set the running execution context's LexicalEnvironment to newEnv.
  2520. // NOTE: Done by CreateLexicalEnvironment.
  2521. }
  2522. }
  2523. } else {
  2524. // Runtime Semantics: ForInOfLoopEvaluation, for any of:
  2525. // ForInOfStatement : for ( LeftHandSideExpression in Expression ) Statement
  2526. // ForInOfStatement : for ( LeftHandSideExpression of AssignmentExpression ) Statement
  2527. result.lhs_kind = LHSKind::Assignment;
  2528. }
  2529. // 3. Let exprRef be the result of evaluating expr.
  2530. auto object = TRY(rhs->generate_bytecode(generator)).value();
  2531. // 4. Set the running execution context's LexicalEnvironment to oldEnv.
  2532. if (entered_lexical_scope)
  2533. generator.end_variable_scope();
  2534. // 5. Let exprValue be ? GetValue(exprRef).
  2535. // NOTE: No need to store this anywhere.
  2536. auto iterator = generator.allocate_register();
  2537. // 6. If iterationKind is enumerate, then
  2538. if (iteration_kind == IterationKind::Enumerate) {
  2539. // a. If exprValue is undefined or null, then
  2540. auto& nullish_block = generator.make_block();
  2541. auto& continuation_block = generator.make_block();
  2542. generator.emit<Bytecode::Op::JumpNullish>(
  2543. object,
  2544. Bytecode::Label { nullish_block },
  2545. Bytecode::Label { continuation_block });
  2546. // i. Return Completion Record { [[Type]]: break, [[Value]]: empty, [[Target]]: empty }.
  2547. generator.switch_to_basic_block(nullish_block);
  2548. generator.generate_break();
  2549. generator.switch_to_basic_block(continuation_block);
  2550. // b. Let obj be ! ToObject(exprValue).
  2551. // NOTE: GetObjectPropertyIterator does this.
  2552. // c. Let iterator be EnumerateObjectProperties(obj).
  2553. // d. Let nextMethod be ! GetV(iterator, "next").
  2554. // e. Return the Iterator Record { [[Iterator]]: iterator, [[NextMethod]]: nextMethod, [[Done]]: false }.
  2555. generator.emit<Bytecode::Op::GetObjectPropertyIterator>(iterator, object);
  2556. }
  2557. // 7. Else,
  2558. else {
  2559. // a. Assert: iterationKind is iterate or async-iterate.
  2560. // b. If iterationKind is async-iterate, let iteratorKind be async.
  2561. // c. Else, let iteratorKind be sync.
  2562. auto iterator_kind = iteration_kind == IterationKind::AsyncIterate ? IteratorHint::Async : IteratorHint::Sync;
  2563. // d. Return ? GetIterator(exprValue, iteratorKind).
  2564. generator.emit<Bytecode::Op::GetIterator>(iterator, object, iterator_kind);
  2565. }
  2566. result.iterator = iterator;
  2567. return result;
  2568. }
  2569. // 14.7.5.7 ForIn/OfBodyEvaluation ( lhs, stmt, iteratorRecord, iterationKind, lhsKind, labelSet [ , iteratorKind ] ), https://tc39.es/ecma262/#sec-runtime-semantics-forin-div-ofbodyevaluation-lhs-stmt-iterator-lhskind-labelset
  2570. static Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> for_in_of_body_evaluation(Bytecode::Generator& generator, ASTNode const& node, Variant<NonnullRefPtr<ASTNode const>, NonnullRefPtr<BindingPattern const>> const& lhs, ASTNode const& body, ForInOfHeadEvaluationResult const& head_result, Vector<DeprecatedFlyString> const& label_set, Bytecode::BasicBlock& loop_end, Bytecode::BasicBlock& loop_update, IteratorHint iterator_kind = IteratorHint::Sync, [[maybe_unused]] Optional<ScopedOperand> preferred_dst = {})
  2571. {
  2572. // 1. If iteratorKind is not present, set iteratorKind to sync.
  2573. // 2. Let oldEnv be the running execution context's LexicalEnvironment.
  2574. bool has_lexical_binding = false;
  2575. // 3. Let V be undefined.
  2576. Optional<ScopedOperand> completion;
  2577. if (generator.must_propagate_completion()) {
  2578. completion = generator.allocate_register();
  2579. generator.emit<Bytecode::Op::Mov>(*completion, generator.add_constant(js_undefined()));
  2580. }
  2581. // 4. Let destructuring be IsDestructuring of lhs.
  2582. auto destructuring = head_result.is_destructuring;
  2583. // 5. If destructuring is true and if lhsKind is assignment, then
  2584. if (destructuring && head_result.lhs_kind == LHSKind::Assignment) {
  2585. // a. Assert: lhs is a LeftHandSideExpression.
  2586. // b. Let assignmentPattern be the AssignmentPattern that is covered by lhs.
  2587. // FIXME: Implement this.
  2588. return Bytecode::CodeGenerationError {
  2589. &node,
  2590. "Unimplemented: assignment destructuring in for/of"sv,
  2591. };
  2592. }
  2593. // 6. Repeat,
  2594. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { loop_update });
  2595. generator.switch_to_basic_block(loop_update);
  2596. generator.begin_continuable_scope(Bytecode::Label { loop_update }, label_set);
  2597. // a. Let nextResult be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]]).
  2598. auto next_result = generator.allocate_register();
  2599. generator.emit<Bytecode::Op::IteratorNext>(next_result, *head_result.iterator);
  2600. // b. If iteratorKind is async, set nextResult to ? Await(nextResult).
  2601. if (iterator_kind == IteratorHint::Async) {
  2602. auto received_completion = generator.allocate_register();
  2603. auto received_completion_type = generator.allocate_register();
  2604. auto received_completion_value = generator.allocate_register();
  2605. auto type_identifier = generator.intern_identifier("type");
  2606. auto value_identifier = generator.intern_identifier("value");
  2607. generator.emit<Bytecode::Op::Mov>(received_completion, generator.accumulator());
  2608. auto new_result = generate_await(generator, next_result, received_completion, received_completion_type, received_completion_value, type_identifier, value_identifier);
  2609. generator.emit<Bytecode::Op::Mov>(next_result, new_result);
  2610. }
  2611. // c. If Type(nextResult) is not Object, throw a TypeError exception.
  2612. generator.emit<Bytecode::Op::ThrowIfNotObject>(next_result);
  2613. // d. Let done be ? IteratorComplete(nextResult).
  2614. auto done = generator.allocate_register();
  2615. generator.emit_iterator_complete(done, next_result);
  2616. // e. If done is true, return V.
  2617. auto& loop_continue = generator.make_block();
  2618. generator.emit_jump_if(
  2619. done,
  2620. Bytecode::Label { loop_end },
  2621. Bytecode::Label { loop_continue });
  2622. generator.switch_to_basic_block(loop_continue);
  2623. // f. Let nextValue be ? IteratorValue(nextResult).
  2624. auto next_value = generator.allocate_register();
  2625. generator.emit_iterator_value(next_value, next_result);
  2626. // g. If lhsKind is either assignment or varBinding, then
  2627. if (head_result.lhs_kind != LHSKind::LexicalBinding) {
  2628. // i. If destructuring is false, then
  2629. if (!destructuring) {
  2630. // 1. Let lhsRef be the result of evaluating lhs. (It may be evaluated repeatedly.)
  2631. // NOTE: We're skipping all the completion stuff that the spec does, as the unwinding mechanism will take case of doing that.
  2632. if (head_result.lhs_kind == LHSKind::VarBinding) {
  2633. auto& declaration = static_cast<VariableDeclaration const&>(*lhs.get<NonnullRefPtr<ASTNode const>>());
  2634. VERIFY(declaration.declarations().size() == 1);
  2635. TRY(assign_value_to_variable_declarator(generator, declaration.declarations().first(), declaration, next_value));
  2636. } else {
  2637. if (auto ptr = lhs.get_pointer<NonnullRefPtr<ASTNode const>>()) {
  2638. TRY(generator.emit_store_to_reference(**ptr, next_value));
  2639. } else {
  2640. auto& binding_pattern = lhs.get<NonnullRefPtr<BindingPattern const>>();
  2641. TRY(binding_pattern->generate_bytecode(generator, Bytecode::Op::BindingInitializationMode::Set, next_value, false));
  2642. }
  2643. }
  2644. }
  2645. }
  2646. // h. Else,
  2647. else {
  2648. // i. Assert: lhsKind is lexicalBinding.
  2649. // ii. Assert: lhs is a ForDeclaration.
  2650. // iii. Let iterationEnv be NewDeclarativeEnvironment(oldEnv).
  2651. // iv. Perform ForDeclarationBindingInstantiation of lhs with argument iterationEnv.
  2652. // v. Set the running execution context's LexicalEnvironment to iterationEnv.
  2653. // 14.7.5.4 Runtime Semantics: ForDeclarationBindingInstantiation, https://tc39.es/ecma262/#sec-runtime-semantics-fordeclarationbindinginstantiation
  2654. // 1. Assert: environment is a declarative Environment Record.
  2655. // NOTE: We just made it.
  2656. auto& variable_declaration = static_cast<VariableDeclaration const&>(*lhs.get<NonnullRefPtr<ASTNode const>>());
  2657. // 2. For each element name of the BoundNames of ForBinding, do
  2658. // NOTE: Nothing in the callback throws an exception.
  2659. auto has_non_local_variables = false;
  2660. MUST(variable_declaration.for_each_bound_identifier([&](auto const& identifier) {
  2661. if (!identifier.is_local())
  2662. has_non_local_variables = true;
  2663. }));
  2664. if (has_non_local_variables) {
  2665. generator.begin_variable_scope();
  2666. has_lexical_binding = true;
  2667. MUST(variable_declaration.for_each_bound_identifier([&](auto const& identifier) {
  2668. if (identifier.is_local())
  2669. return;
  2670. auto interned_identifier = generator.intern_identifier(identifier.string());
  2671. // a. If IsConstantDeclaration of LetOrConst is true, then
  2672. if (variable_declaration.is_constant_declaration()) {
  2673. // i. Perform ! environment.CreateImmutableBinding(name, true).
  2674. generator.emit<Bytecode::Op::CreateVariable>(interned_identifier, Bytecode::Op::EnvironmentMode::Lexical, true, false, true);
  2675. }
  2676. // b. Else,
  2677. else {
  2678. // i. Perform ! environment.CreateMutableBinding(name, false).
  2679. generator.emit<Bytecode::Op::CreateVariable>(interned_identifier, Bytecode::Op::EnvironmentMode::Lexical, false);
  2680. }
  2681. }));
  2682. // 3. Return unused.
  2683. // NOTE: No need to do that as we've inlined this.
  2684. }
  2685. // vi. If destructuring is false, then
  2686. if (!destructuring) {
  2687. // 1. Assert: lhs binds a single name.
  2688. // 2. Let lhsName be the sole element of BoundNames of lhs.
  2689. auto lhs_name = variable_declaration.declarations().first()->target().get<NonnullRefPtr<Identifier const>>();
  2690. // 3. Let lhsRef be ! ResolveBinding(lhsName).
  2691. // NOTE: We're skipping all the completion stuff that the spec does, as the unwinding mechanism will take case of doing that.
  2692. generator.emit_set_variable(*lhs_name, next_value, Bytecode::Op::BindingInitializationMode::Initialize, Bytecode::Op::EnvironmentMode::Lexical);
  2693. }
  2694. }
  2695. // i. If destructuring is false, then
  2696. if (!destructuring) {
  2697. // i. If lhsRef is an abrupt completion, then
  2698. // 1. Let status be lhsRef.
  2699. // ii. Else if lhsKind is lexicalBinding, then
  2700. // 1. Let status be Completion(InitializeReferencedBinding(lhsRef, nextValue)).
  2701. // iii. Else,
  2702. // 1. Let status be Completion(PutValue(lhsRef, nextValue)).
  2703. // NOTE: This is performed above.
  2704. }
  2705. // j. Else,
  2706. else {
  2707. // FIXME: i. If lhsKind is assignment, then
  2708. // 1. Let status be Completion(DestructuringAssignmentEvaluation of assignmentPattern with argument nextValue).
  2709. // ii. Else if lhsKind is varBinding, then
  2710. // 1. Assert: lhs is a ForBinding.
  2711. // 2. Let status be Completion(BindingInitialization of lhs with arguments nextValue and undefined).
  2712. // iii. Else,
  2713. // 1. Assert: lhsKind is lexicalBinding.
  2714. // 2. Assert: lhs is a ForDeclaration.
  2715. // 3. Let status be Completion(ForDeclarationBindingInitialization of lhs with arguments nextValue and iterationEnv).
  2716. if (head_result.lhs_kind == LHSKind::VarBinding || head_result.lhs_kind == LHSKind::LexicalBinding) {
  2717. auto& declaration = static_cast<VariableDeclaration const&>(*lhs.get<NonnullRefPtr<ASTNode const>>());
  2718. VERIFY(declaration.declarations().size() == 1);
  2719. auto& binding_pattern = declaration.declarations().first()->target().get<NonnullRefPtr<BindingPattern const>>();
  2720. (void)TRY(binding_pattern->generate_bytecode(
  2721. generator,
  2722. head_result.lhs_kind == LHSKind::VarBinding ? Bytecode::Op::BindingInitializationMode::Set : Bytecode::Op::BindingInitializationMode::Initialize,
  2723. next_value,
  2724. false));
  2725. } else {
  2726. return Bytecode::CodeGenerationError {
  2727. &node,
  2728. "Unimplemented: assignment destructuring in for/of"sv,
  2729. };
  2730. }
  2731. }
  2732. // FIXME: Implement iteration closure.
  2733. // k. If status is an abrupt completion, then
  2734. // i. Set the running execution context's LexicalEnvironment to oldEnv.
  2735. // ii. If iteratorKind is async, return ? AsyncIteratorClose(iteratorRecord, status).
  2736. // iii. If iterationKind is enumerate, then
  2737. // 1. Return ? status.
  2738. // iv. Else,
  2739. // 1. Assert: iterationKind is iterate.
  2740. // 2. Return ? IteratorClose(iteratorRecord, status).
  2741. // l. Let result be the result of evaluating stmt.
  2742. auto result = TRY(body.generate_bytecode(generator));
  2743. // m. Set the running execution context's LexicalEnvironment to oldEnv.
  2744. if (has_lexical_binding)
  2745. generator.end_variable_scope();
  2746. generator.end_continuable_scope();
  2747. generator.end_breakable_scope();
  2748. // NOTE: If we're here, then the loop definitely continues.
  2749. // n. If LoopContinues(result, labelSet) is false, then
  2750. // i. If iterationKind is enumerate, then
  2751. // 1. Return ? UpdateEmpty(result, V).
  2752. // ii. Else,
  2753. // 1. Assert: iterationKind is iterate.
  2754. // 2. Set status to Completion(UpdateEmpty(result, V)).
  2755. // 3. If iteratorKind is async, return ? AsyncIteratorClose(iteratorRecord, status).
  2756. // 4. Return ? IteratorClose(iteratorRecord, status).
  2757. // o. If result.[[Value]] is not empty, set V to result.[[Value]].
  2758. // The body can contain an unconditional block terminator (e.g. return, throw), so we have to check for that before generating the Jump.
  2759. if (!generator.is_current_block_terminated()) {
  2760. if (generator.must_propagate_completion()) {
  2761. if (result.has_value())
  2762. generator.emit<Bytecode::Op::Mov>(*completion, *result);
  2763. }
  2764. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { loop_update });
  2765. }
  2766. generator.switch_to_basic_block(loop_end);
  2767. return completion;
  2768. }
  2769. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ForInStatement::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  2770. {
  2771. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  2772. return generate_labelled_evaluation(generator, {});
  2773. }
  2774. // 14.7.5.5 Runtime Semantics: ForInOfLoopEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-forinofloopevaluation
  2775. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ForInStatement::generate_labelled_evaluation(Bytecode::Generator& generator, Vector<DeprecatedFlyString> const& label_set, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  2776. {
  2777. auto& loop_end = generator.make_block();
  2778. auto& loop_update = generator.make_block();
  2779. generator.begin_breakable_scope(Bytecode::Label { loop_end }, label_set);
  2780. auto head_result = TRY(for_in_of_head_evaluation(generator, IterationKind::Enumerate, m_lhs, m_rhs));
  2781. return for_in_of_body_evaluation(generator, *this, m_lhs, body(), head_result, label_set, loop_end, loop_update);
  2782. }
  2783. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ForOfStatement::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  2784. {
  2785. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  2786. return generate_labelled_evaluation(generator, {});
  2787. }
  2788. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ForOfStatement::generate_labelled_evaluation(Bytecode::Generator& generator, Vector<DeprecatedFlyString> const& label_set, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  2789. {
  2790. auto& loop_end = generator.make_block();
  2791. auto& loop_update = generator.make_block();
  2792. generator.begin_breakable_scope(Bytecode::Label { loop_end }, label_set);
  2793. auto head_result = TRY(for_in_of_head_evaluation(generator, IterationKind::Iterate, m_lhs, m_rhs));
  2794. return for_in_of_body_evaluation(generator, *this, m_lhs, body(), head_result, label_set, loop_end, loop_update);
  2795. }
  2796. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ForAwaitOfStatement::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  2797. {
  2798. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  2799. return generate_labelled_evaluation(generator, {});
  2800. }
  2801. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ForAwaitOfStatement::generate_labelled_evaluation(Bytecode::Generator& generator, Vector<DeprecatedFlyString> const& label_set, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  2802. {
  2803. auto& loop_end = generator.make_block();
  2804. auto& loop_update = generator.make_block();
  2805. generator.begin_breakable_scope(Bytecode::Label { loop_end }, label_set);
  2806. auto head_result = TRY(for_in_of_head_evaluation(generator, IterationKind::AsyncIterate, m_lhs, m_rhs));
  2807. return for_in_of_body_evaluation(generator, *this, m_lhs, m_body, head_result, label_set, loop_end, loop_update, IteratorHint::Async);
  2808. }
  2809. // 13.3.12.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-meta-properties-runtime-semantics-evaluation
  2810. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> MetaProperty::generate_bytecode(Bytecode::Generator& generator, Optional<ScopedOperand> preferred_dst) const
  2811. {
  2812. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  2813. // NewTarget : new . target
  2814. if (m_type == MetaProperty::Type::NewTarget) {
  2815. // 1. Return GetNewTarget().
  2816. auto dst = choose_dst(generator, preferred_dst);
  2817. generator.emit<Bytecode::Op::GetNewTarget>(dst);
  2818. return dst;
  2819. }
  2820. // ImportMeta : import . meta
  2821. if (m_type == MetaProperty::Type::ImportMeta) {
  2822. auto dst = choose_dst(generator, preferred_dst);
  2823. generator.emit<Bytecode::Op::GetImportMeta>(dst);
  2824. return dst;
  2825. }
  2826. VERIFY_NOT_REACHED();
  2827. }
  2828. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ClassFieldInitializerStatement::generate_bytecode(Bytecode::Generator& generator, Optional<ScopedOperand> preferred_dst) const
  2829. {
  2830. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  2831. auto value = TRY(generator.emit_named_evaluation_if_anonymous_function(*m_expression, generator.intern_identifier(m_class_field_identifier_name), preferred_dst));
  2832. generator.perform_needed_unwinds<Bytecode::Op::Return>();
  2833. generator.emit<Bytecode::Op::Return>(value.has_value() ? value->operand() : Optional<Operand> {});
  2834. return value;
  2835. }
  2836. static Bytecode::CodeGenerationErrorOr<void> generate_optional_chain(Bytecode::Generator& generator, OptionalChain const& optional_chain, ScopedOperand current_value, ScopedOperand current_base, [[maybe_unused]] Optional<ScopedOperand> preferred_dst)
  2837. {
  2838. Optional<ScopedOperand> new_current_value;
  2839. if (is<MemberExpression>(optional_chain.base())) {
  2840. auto& member_expression = static_cast<MemberExpression const&>(optional_chain.base());
  2841. auto base_and_value = TRY(get_base_and_value_from_member_expression(generator, member_expression));
  2842. new_current_value = base_and_value.value;
  2843. generator.emit<Bytecode::Op::Mov>(current_base, base_and_value.base);
  2844. } else if (is<OptionalChain>(optional_chain.base())) {
  2845. auto& sub_optional_chain = static_cast<OptionalChain const&>(optional_chain.base());
  2846. TRY(generate_optional_chain(generator, sub_optional_chain, current_value, current_base));
  2847. new_current_value = current_value;
  2848. } else {
  2849. new_current_value = TRY(optional_chain.base().generate_bytecode(generator)).value();
  2850. }
  2851. generator.emit<Bytecode::Op::Mov>(current_value, *new_current_value);
  2852. auto& load_undefined_and_jump_to_end_block = generator.make_block();
  2853. auto& end_block = generator.make_block();
  2854. for (auto& reference : optional_chain.references()) {
  2855. auto is_optional = reference.visit([](auto& ref) { return ref.mode; }) == OptionalChain::Mode::Optional;
  2856. if (is_optional) {
  2857. auto& not_nullish_block = generator.make_block();
  2858. generator.emit<Bytecode::Op::JumpNullish>(
  2859. current_value,
  2860. Bytecode::Label { load_undefined_and_jump_to_end_block },
  2861. Bytecode::Label { not_nullish_block });
  2862. generator.switch_to_basic_block(not_nullish_block);
  2863. }
  2864. TRY(reference.visit(
  2865. [&](OptionalChain::Call const& call) -> Bytecode::CodeGenerationErrorOr<void> {
  2866. auto arguments = TRY(arguments_to_array_for_call(generator, call.arguments)).value();
  2867. generator.emit<Bytecode::Op::CallWithArgumentArray>(Bytecode::Op::CallType::Call, current_value, current_value, current_base, arguments);
  2868. generator.emit<Bytecode::Op::Mov>(current_base, generator.add_constant(js_undefined()));
  2869. return {};
  2870. },
  2871. [&](OptionalChain::ComputedReference const& ref) -> Bytecode::CodeGenerationErrorOr<void> {
  2872. generator.emit<Bytecode::Op::Mov>(current_base, current_value);
  2873. auto property = TRY(ref.expression->generate_bytecode(generator)).value();
  2874. generator.emit<Bytecode::Op::GetByValue>(current_value, current_value, property);
  2875. return {};
  2876. },
  2877. [&](OptionalChain::MemberReference const& ref) -> Bytecode::CodeGenerationErrorOr<void> {
  2878. generator.emit<Bytecode::Op::Mov>(current_base, current_value);
  2879. generator.emit_get_by_id(current_value, current_value, generator.intern_identifier(ref.identifier->string()));
  2880. return {};
  2881. },
  2882. [&](OptionalChain::PrivateMemberReference const& ref) -> Bytecode::CodeGenerationErrorOr<void> {
  2883. generator.emit<Bytecode::Op::Mov>(current_base, current_value);
  2884. generator.emit<Bytecode::Op::GetPrivateById>(current_value, current_value, generator.intern_identifier(ref.private_identifier->string()));
  2885. return {};
  2886. }));
  2887. }
  2888. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { end_block });
  2889. generator.switch_to_basic_block(load_undefined_and_jump_to_end_block);
  2890. generator.emit<Bytecode::Op::Mov>(current_value, generator.add_constant(js_undefined()));
  2891. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { end_block });
  2892. generator.switch_to_basic_block(end_block);
  2893. return {};
  2894. }
  2895. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> OptionalChain::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  2896. {
  2897. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  2898. auto current_base = generator.allocate_register();
  2899. auto current_value = choose_dst(generator, preferred_dst);
  2900. generator.emit<Bytecode::Op::Mov>(current_base, generator.add_constant(js_undefined()));
  2901. TRY(generate_optional_chain(generator, *this, current_value, current_base));
  2902. return current_value;
  2903. }
  2904. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ImportCall::generate_bytecode(Bytecode::Generator& generator, Optional<ScopedOperand> preferred_dst) const
  2905. {
  2906. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  2907. auto specifier = TRY(m_specifier->generate_bytecode(generator)).value();
  2908. Optional<ScopedOperand> options;
  2909. if (m_options) {
  2910. options = TRY(m_options->generate_bytecode(generator)).value();
  2911. } else {
  2912. options = generator.add_constant(js_undefined());
  2913. }
  2914. auto dst = choose_dst(generator, preferred_dst);
  2915. generator.emit<Bytecode::Op::ImportCall>(dst, specifier, *options);
  2916. return dst;
  2917. }
  2918. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ExportStatement::generate_bytecode(Bytecode::Generator& generator, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  2919. {
  2920. Bytecode::Generator::SourceLocationScope scope(generator, *this);
  2921. if (!is_default_export()) {
  2922. if (m_statement) {
  2923. return m_statement->generate_bytecode(generator);
  2924. }
  2925. return Optional<ScopedOperand> {};
  2926. }
  2927. VERIFY(m_statement);
  2928. if (is<FunctionDeclaration>(*m_statement) || is<ClassDeclaration>(*m_statement)) {
  2929. return m_statement->generate_bytecode(generator);
  2930. }
  2931. if (is<ClassExpression>(*m_statement)) {
  2932. auto value = TRY(generator.emit_named_evaluation_if_anonymous_function(static_cast<ClassExpression const&>(*m_statement), generator.intern_identifier("default"sv))).value();
  2933. if (!static_cast<ClassExpression const&>(*m_statement).has_name()) {
  2934. generator.emit<Bytecode::Op::InitializeLexicalBinding>(
  2935. generator.intern_identifier(ExportStatement::local_name_for_default),
  2936. value);
  2937. }
  2938. return value;
  2939. }
  2940. // ExportDeclaration : export default AssignmentExpression ;
  2941. VERIFY(is<Expression>(*m_statement));
  2942. auto value = TRY(generator.emit_named_evaluation_if_anonymous_function(static_cast<Expression const&>(*m_statement), generator.intern_identifier("default"sv))).value();
  2943. generator.emit<Bytecode::Op::InitializeLexicalBinding>(
  2944. generator.intern_identifier(ExportStatement::local_name_for_default),
  2945. value);
  2946. return value;
  2947. }
  2948. Bytecode::CodeGenerationErrorOr<Optional<ScopedOperand>> ImportStatement::generate_bytecode(Bytecode::Generator&, [[maybe_unused]] Optional<ScopedOperand> preferred_dst) const
  2949. {
  2950. return Optional<ScopedOperand> {};
  2951. }
  2952. }