Compiler.cpp 62 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713
  1. /*
  2. * Copyright (c) 2023, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2023, Simon Wanner <simon@skyrising.xyz>
  4. *
  5. * SPDX-License-Identifier: BSD-2-Clause
  6. */
  7. #include <AK/OwnPtr.h>
  8. #include <AK/Platform.h>
  9. #include <LibJS/Bytecode/CommonImplementations.h>
  10. #include <LibJS/Bytecode/Instruction.h>
  11. #include <LibJS/Bytecode/Interpreter.h>
  12. #include <LibJS/Bytecode/RegexTable.h>
  13. #include <LibJS/JIT/Compiler.h>
  14. #include <LibJS/Runtime/AbstractOperations.h>
  15. #include <LibJS/Runtime/Array.h>
  16. #include <LibJS/Runtime/DeclarativeEnvironment.h>
  17. #include <LibJS/Runtime/ECMAScriptFunctionObject.h>
  18. #include <LibJS/Runtime/FunctionEnvironment.h>
  19. #include <LibJS/Runtime/VM.h>
  20. #include <LibJS/Runtime/ValueInlines.h>
  21. #include <sys/mman.h>
  22. #include <unistd.h>
  23. #if ARCH(X86_64)
  24. # define LOG_JIT_SUCCESS 1
  25. # define LOG_JIT_FAILURE 1
  26. # define DUMP_JIT_MACHINE_CODE_TO_STDOUT 0
  27. # define DUMP_JIT_DISASSEMBLY 0
  28. # define TRY_OR_SET_EXCEPTION(expression) \
  29. ({ \
  30. /* Ignore -Wshadow to allow nesting the macro. */ \
  31. AK_IGNORE_DIAGNOSTIC("-Wshadow", \
  32. auto&& _temporary_result = (expression)); \
  33. static_assert(!::AK::Detail::IsLvalueReference<decltype(_temporary_result.release_value())>, \
  34. "Do not return a reference from a fallible expression"); \
  35. if (_temporary_result.is_error()) [[unlikely]] { \
  36. vm.bytecode_interpreter().reg(Bytecode::Register::exception()) = _temporary_result.release_error().value().value(); \
  37. return {}; \
  38. } \
  39. _temporary_result.release_value(); \
  40. })
  41. namespace JS::JIT {
  42. void Compiler::store_vm_register(Bytecode::Register dst, Assembler::Reg src)
  43. {
  44. m_assembler.mov(
  45. Assembler::Operand::Mem64BaseAndOffset(REGISTER_ARRAY_BASE, dst.index() * sizeof(Value)),
  46. Assembler::Operand::Register(src));
  47. }
  48. void Compiler::load_vm_register(Assembler::Reg dst, Bytecode::Register src)
  49. {
  50. m_assembler.mov(
  51. Assembler::Operand::Register(dst),
  52. Assembler::Operand::Mem64BaseAndOffset(REGISTER_ARRAY_BASE, src.index() * sizeof(Value)));
  53. }
  54. void Compiler::store_vm_local(size_t dst, Assembler::Reg src)
  55. {
  56. m_assembler.mov(
  57. Assembler::Operand::Mem64BaseAndOffset(LOCALS_ARRAY_BASE, dst * sizeof(Value)),
  58. Assembler::Operand::Register(src));
  59. }
  60. void Compiler::load_vm_local(Assembler::Reg dst, size_t src)
  61. {
  62. m_assembler.mov(
  63. Assembler::Operand::Register(dst),
  64. Assembler::Operand::Mem64BaseAndOffset(LOCALS_ARRAY_BASE, src * sizeof(Value)));
  65. }
  66. void Compiler::compile_load_immediate(Bytecode::Op::LoadImmediate const& op)
  67. {
  68. m_assembler.mov(
  69. Assembler::Operand::Register(GPR0),
  70. Assembler::Operand::Imm(op.value().encoded()));
  71. store_vm_register(Bytecode::Register::accumulator(), GPR0);
  72. }
  73. void Compiler::compile_load(Bytecode::Op::Load const& op)
  74. {
  75. load_vm_register(GPR0, op.src());
  76. store_vm_register(Bytecode::Register::accumulator(), GPR0);
  77. }
  78. void Compiler::compile_store(Bytecode::Op::Store const& op)
  79. {
  80. load_vm_register(GPR0, Bytecode::Register::accumulator());
  81. store_vm_register(op.dst(), GPR0);
  82. }
  83. void Compiler::compile_get_local(Bytecode::Op::GetLocal const& op)
  84. {
  85. load_vm_local(GPR0, op.index());
  86. store_vm_register(Bytecode::Register::accumulator(), GPR0);
  87. }
  88. void Compiler::compile_set_local(Bytecode::Op::SetLocal const& op)
  89. {
  90. load_vm_register(GPR0, Bytecode::Register::accumulator());
  91. store_vm_local(op.index(), GPR0);
  92. }
  93. static Value cxx_typeof_local(VM& vm, Value value)
  94. {
  95. return PrimitiveString::create(vm, value.typeof());
  96. }
  97. void Compiler::compile_typeof_local(Bytecode::Op::TypeofLocal const& op)
  98. {
  99. load_vm_local(ARG1, op.index());
  100. native_call((void*)cxx_typeof_local);
  101. store_vm_register(Bytecode::Register::accumulator(), GPR0);
  102. }
  103. void Compiler::compile_jump(Bytecode::Op::Jump const& op)
  104. {
  105. m_assembler.jump(label_for(op.true_target()->block()));
  106. }
  107. static bool cxx_to_boolean(VM&, Value value)
  108. {
  109. return value.to_boolean();
  110. }
  111. void Compiler::compile_to_boolean(Assembler::Reg dst, Assembler::Reg src)
  112. {
  113. // dst = src;
  114. m_assembler.mov(
  115. Assembler::Operand::Register(dst),
  116. Assembler::Operand::Register(src));
  117. // dst >>= 48;
  118. m_assembler.shift_right(
  119. Assembler::Operand::Register(dst),
  120. Assembler::Operand::Imm(48));
  121. // if (dst != BOOLEAN_TAG) goto slow_case;
  122. Assembler::Label slow_case {};
  123. m_assembler.jump_if(
  124. Assembler::Operand::Register(dst),
  125. Assembler::Condition::NotEqualTo,
  126. Assembler::Operand::Imm(BOOLEAN_TAG),
  127. slow_case);
  128. // Fast path for JS::Value booleans.
  129. // dst = src;
  130. m_assembler.mov(
  131. Assembler::Operand::Register(dst),
  132. Assembler::Operand::Register(src));
  133. // goto end;
  134. auto end = m_assembler.jump();
  135. // slow_case: // call C++ helper
  136. slow_case.link(m_assembler);
  137. m_assembler.mov(
  138. Assembler::Operand::Register(ARG1),
  139. Assembler::Operand::Register(src));
  140. native_call((void*)cxx_to_boolean);
  141. m_assembler.mov(
  142. Assembler::Operand::Register(dst),
  143. Assembler::Operand::Register(RET));
  144. // end:
  145. end.link(m_assembler);
  146. // dst &= 1;
  147. m_assembler.bitwise_and(
  148. Assembler::Operand::Register(dst),
  149. Assembler::Operand::Imm(1));
  150. }
  151. void Compiler::compile_jump_conditional(Bytecode::Op::JumpConditional const& op)
  152. {
  153. load_vm_register(GPR1, Bytecode::Register::accumulator());
  154. compile_to_boolean(GPR0, GPR1);
  155. m_assembler.jump_if(
  156. Assembler::Operand::Register(GPR0),
  157. Assembler::Condition::EqualTo,
  158. Assembler::Operand::Imm(0),
  159. label_for(op.false_target()->block()));
  160. m_assembler.jump(label_for(op.true_target()->block()));
  161. }
  162. void Compiler::compile_jump_nullish(Bytecode::Op::JumpNullish const& op)
  163. {
  164. load_vm_register(GPR0, Bytecode::Register::accumulator());
  165. m_assembler.shift_right(
  166. Assembler::Operand::Register(GPR0),
  167. Assembler::Operand::Imm(48));
  168. m_assembler.bitwise_and(
  169. Assembler::Operand::Register(GPR0),
  170. Assembler::Operand::Imm(IS_NULLISH_EXTRACT_PATTERN));
  171. m_assembler.jump_if(
  172. Assembler::Operand::Register(GPR0),
  173. Assembler::Condition::EqualTo,
  174. Assembler::Operand::Imm(IS_NULLISH_PATTERN),
  175. label_for(op.true_target()->block()));
  176. m_assembler.jump(label_for(op.false_target()->block()));
  177. }
  178. [[maybe_unused]] static Value cxx_increment(VM& vm, Value value)
  179. {
  180. auto old_value = TRY_OR_SET_EXCEPTION(value.to_numeric(vm));
  181. if (old_value.is_number())
  182. return Value(old_value.as_double() + 1);
  183. return BigInt::create(vm, old_value.as_bigint().big_integer().plus(Crypto::SignedBigInteger { 1 }));
  184. }
  185. template<typename Codegen>
  186. void Compiler::branch_if_int32(Assembler::Reg reg, Codegen codegen)
  187. {
  188. // GPR0 = reg >> 48;
  189. m_assembler.mov(Assembler::Operand::Register(GPR0), Assembler::Operand::Register(reg));
  190. m_assembler.shift_right(Assembler::Operand::Register(GPR0), Assembler::Operand::Imm(48));
  191. Assembler::Label not_int32_case {};
  192. m_assembler.jump_if(
  193. Assembler::Operand::Register(GPR0),
  194. Assembler::Condition::NotEqualTo,
  195. Assembler::Operand::Imm(INT32_TAG),
  196. not_int32_case);
  197. codegen();
  198. not_int32_case.link(m_assembler);
  199. }
  200. template<typename Codegen>
  201. void Compiler::branch_if_both_int32(Assembler::Reg lhs, Assembler::Reg rhs, Codegen codegen)
  202. {
  203. // GPR0 = lhs >> 48;
  204. m_assembler.mov(Assembler::Operand::Register(GPR0), Assembler::Operand::Register(lhs));
  205. m_assembler.shift_right(Assembler::Operand::Register(GPR0), Assembler::Operand::Imm(48));
  206. // GPR1 = rhs >> 48;
  207. m_assembler.mov(Assembler::Operand::Register(GPR1), Assembler::Operand::Register(rhs));
  208. m_assembler.shift_right(Assembler::Operand::Register(GPR1), Assembler::Operand::Imm(48));
  209. Assembler::Label not_int32_case {};
  210. m_assembler.jump_if(
  211. Assembler::Operand::Register(GPR0),
  212. Assembler::Condition::NotEqualTo,
  213. Assembler::Operand::Imm(INT32_TAG),
  214. not_int32_case);
  215. m_assembler.jump_if(
  216. Assembler::Operand::Register(GPR1),
  217. Assembler::Condition::NotEqualTo,
  218. Assembler::Operand::Imm(INT32_TAG),
  219. not_int32_case);
  220. codegen();
  221. not_int32_case.link(m_assembler);
  222. }
  223. void Compiler::compile_increment(Bytecode::Op::Increment const&)
  224. {
  225. load_vm_register(ARG1, Bytecode::Register::accumulator());
  226. Assembler::Label end {};
  227. Assembler::Label slow_case {};
  228. branch_if_int32(ARG1, [&] {
  229. // GPR0 = ARG1 & 0xffffffff;
  230. m_assembler.mov(
  231. Assembler::Operand::Register(GPR0),
  232. Assembler::Operand::Register(ARG1));
  233. m_assembler.mov(
  234. Assembler::Operand::Register(GPR1),
  235. Assembler::Operand::Imm(0xffffffff));
  236. m_assembler.bitwise_and(
  237. Assembler::Operand::Register(GPR0),
  238. Assembler::Operand::Register(GPR1));
  239. // if (GPR0 == 0x7fffffff) goto slow_case;
  240. m_assembler.jump_if(
  241. Assembler::Operand::Register(GPR0),
  242. Assembler::Condition::EqualTo,
  243. Assembler::Operand::Imm(0x7fffffff),
  244. slow_case);
  245. // ARG1 += 1;
  246. m_assembler.add(
  247. Assembler::Operand::Register(ARG1),
  248. Assembler::Operand::Imm(1));
  249. // accumulator = ARG1;
  250. store_vm_register(Bytecode::Register::accumulator(), ARG1);
  251. m_assembler.jump(end);
  252. });
  253. slow_case.link(m_assembler);
  254. native_call((void*)cxx_increment);
  255. store_vm_register(Bytecode::Register::accumulator(), RET);
  256. check_exception();
  257. end.link(m_assembler);
  258. }
  259. static Value cxx_decrement(VM& vm, Value value)
  260. {
  261. auto old_value = TRY_OR_SET_EXCEPTION(value.to_numeric(vm));
  262. if (old_value.is_number())
  263. return Value(old_value.as_double() - 1);
  264. return BigInt::create(vm, old_value.as_bigint().big_integer().minus(Crypto::SignedBigInteger { 1 }));
  265. }
  266. void Compiler::compile_decrement(Bytecode::Op::Decrement const&)
  267. {
  268. load_vm_register(ARG1, Bytecode::Register::accumulator());
  269. native_call((void*)cxx_decrement);
  270. store_vm_register(Bytecode::Register::accumulator(), RET);
  271. check_exception();
  272. }
  273. void Compiler::check_exception()
  274. {
  275. // if (!exception.is_empty()) goto m_exception_handler;
  276. load_vm_register(GPR0, Bytecode::Register::exception());
  277. m_assembler.mov(Assembler::Operand::Register(GPR1), Assembler::Operand::Imm(Value().encoded()));
  278. m_assembler.jump_if(
  279. Assembler::Operand::Register(GPR0),
  280. Assembler::Condition::NotEqualTo,
  281. Assembler::Operand::Register(GPR1),
  282. m_exception_handler);
  283. }
  284. void Compiler::handle_exception()
  285. {
  286. // if (!unwind_context.valid) return;
  287. Assembler::Label handle_exception {};
  288. m_assembler.mov(
  289. Assembler::Operand::Register(GPR0),
  290. Assembler::Operand::Mem64BaseAndOffset(UNWIND_CONTEXT_BASE, 0));
  291. m_assembler.jump_if(
  292. Assembler::Operand::Register(GPR0),
  293. Assembler::Condition::NotEqualTo,
  294. Assembler::Operand::Imm(0),
  295. handle_exception);
  296. jump_to_exit();
  297. // handle_exception:
  298. handle_exception.link(m_assembler);
  299. // if (unwind_context.handler) {
  300. Assembler::Label no_handler {};
  301. m_assembler.mov(
  302. Assembler::Operand::Register(GPR0),
  303. Assembler::Operand::Mem64BaseAndOffset(UNWIND_CONTEXT_BASE, 8));
  304. m_assembler.jump_if(
  305. Assembler::Operand::Register(GPR0),
  306. Assembler::Condition::EqualTo,
  307. Assembler::Operand::Imm(0),
  308. no_handler);
  309. // accumulator = exception;
  310. load_vm_register(GPR1, Bytecode::Register::exception());
  311. store_vm_register(Bytecode::Register::accumulator(), GPR1);
  312. // exception = Value();
  313. m_assembler.mov(
  314. Assembler::Operand::Register(GPR1),
  315. Assembler::Operand::Imm(Value().encoded()));
  316. store_vm_register(Bytecode::Register::exception(), GPR1);
  317. // unwind_context.handler = nullptr;
  318. m_assembler.mov(
  319. Assembler::Operand::Register(GPR1),
  320. Assembler::Operand::Imm(0));
  321. m_assembler.mov(
  322. Assembler::Operand::Mem64BaseAndOffset(UNWIND_CONTEXT_BASE, 8),
  323. Assembler::Operand::Register(GPR1));
  324. // goto handler;
  325. m_assembler.jump(Assembler::Operand::Register(GPR0));
  326. // }
  327. // no_handler:
  328. no_handler.link(m_assembler);
  329. // if (unwind_context.finalizer) goto finalizer;
  330. Assembler::Label no_finalizer {};
  331. m_assembler.mov(
  332. Assembler::Operand::Register(GPR0),
  333. Assembler::Operand::Mem64BaseAndOffset(UNWIND_CONTEXT_BASE, 16));
  334. m_assembler.jump_if(
  335. Assembler::Operand::Register(GPR0),
  336. Assembler::Condition::EqualTo,
  337. Assembler::Operand::Imm(0),
  338. no_finalizer);
  339. m_assembler.jump(Assembler::Operand::Register(GPR0));
  340. // no_finalizer:
  341. // NOTE: No catch and no finally!? Crash.
  342. no_finalizer.link(m_assembler);
  343. m_assembler.verify_not_reached();
  344. }
  345. void Compiler::push_unwind_context(bool valid, Optional<Bytecode::Label> const& handler, Optional<Bytecode::Label> const& finalizer)
  346. {
  347. // Put this on the stack, and then point UNWIND_CONTEXT_BASE at it.
  348. // struct {
  349. // u64 valid;
  350. // u64 handler;
  351. // u64 finalizer;
  352. // };
  353. if (finalizer.has_value()) {
  354. // push finalizer (patched later)
  355. m_assembler.mov(
  356. Assembler::Operand::Register(GPR0),
  357. Assembler::Operand::Imm(0),
  358. Assembler::Patchable::Yes);
  359. block_data_for(finalizer.value().block()).absolute_references_to_here.append(m_assembler.m_output.size() - 8);
  360. m_assembler.push(Assembler::Operand::Register(GPR0));
  361. } else {
  362. m_assembler.push(Assembler::Operand::Imm(0));
  363. }
  364. if (handler.has_value()) {
  365. // push handler (patched later)
  366. m_assembler.mov(
  367. Assembler::Operand::Register(GPR0),
  368. Assembler::Operand::Imm(0),
  369. Assembler::Patchable::Yes);
  370. block_data_for(handler.value().block()).absolute_references_to_here.append(m_assembler.m_output.size() - 8);
  371. m_assembler.push(Assembler::Operand::Register(GPR0));
  372. } else {
  373. m_assembler.push(Assembler::Operand::Imm(0));
  374. }
  375. // push valid
  376. m_assembler.push(Assembler::Operand::Imm(valid));
  377. // UNWIND_CONTEXT_BASE = STACK_POINTER
  378. m_assembler.mov(
  379. Assembler::Operand::Register(UNWIND_CONTEXT_BASE),
  380. Assembler::Operand::Register(STACK_POINTER));
  381. // align stack pointer
  382. m_assembler.sub(Assembler::Operand::Register(STACK_POINTER), Assembler::Operand::Imm(8));
  383. }
  384. void Compiler::pop_unwind_context()
  385. {
  386. m_assembler.add(Assembler::Operand::Register(STACK_POINTER), Assembler::Operand::Imm(32));
  387. m_assembler.add(Assembler::Operand::Register(UNWIND_CONTEXT_BASE), Assembler::Operand::Imm(32));
  388. }
  389. void Compiler::compile_enter_unwind_context(Bytecode::Op::EnterUnwindContext const& op)
  390. {
  391. push_unwind_context(true, op.handler_target(), op.finalizer_target());
  392. m_assembler.jump(label_for(op.entry_point().block()));
  393. }
  394. void Compiler::compile_leave_unwind_context(Bytecode::Op::LeaveUnwindContext const&)
  395. {
  396. pop_unwind_context();
  397. }
  398. void Compiler::compile_throw(Bytecode::Op::Throw const&)
  399. {
  400. load_vm_register(GPR0, Bytecode::Register::accumulator());
  401. store_vm_register(Bytecode::Register::exception(), GPR0);
  402. check_exception();
  403. }
  404. static ThrowCompletionOr<Value> abstract_inequals(VM& vm, Value src1, Value src2)
  405. {
  406. return Value(!TRY(is_loosely_equal(vm, src1, src2)));
  407. }
  408. static ThrowCompletionOr<Value> abstract_equals(VM& vm, Value src1, Value src2)
  409. {
  410. return Value(TRY(is_loosely_equal(vm, src1, src2)));
  411. }
  412. static ThrowCompletionOr<Value> typed_inequals(VM&, Value src1, Value src2)
  413. {
  414. return Value(!is_strictly_equal(src1, src2));
  415. }
  416. static ThrowCompletionOr<Value> typed_equals(VM&, Value src1, Value src2)
  417. {
  418. return Value(is_strictly_equal(src1, src2));
  419. }
  420. # define DO_COMPILE_COMMON_BINARY_OP(TitleCaseName, snake_case_name) \
  421. static Value cxx_##snake_case_name(VM& vm, Value lhs, Value rhs) \
  422. { \
  423. return TRY_OR_SET_EXCEPTION(snake_case_name(vm, lhs, rhs)); \
  424. } \
  425. \
  426. void Compiler::compile_##snake_case_name(Bytecode::Op::TitleCaseName const& op) \
  427. { \
  428. load_vm_register(ARG1, op.lhs()); \
  429. load_vm_register(ARG2, Bytecode::Register::accumulator()); \
  430. native_call((void*)cxx_##snake_case_name); \
  431. store_vm_register(Bytecode::Register::accumulator(), RET); \
  432. check_exception(); \
  433. }
  434. JS_ENUMERATE_COMMON_BINARY_OPS_WITHOUT_FAST_PATH(DO_COMPILE_COMMON_BINARY_OP)
  435. # undef DO_COMPILE_COMMON_BINARY_OP
  436. static Value cxx_add(VM& vm, Value lhs, Value rhs)
  437. {
  438. return TRY_OR_SET_EXCEPTION(add(vm, lhs, rhs));
  439. }
  440. void Compiler::compile_add(Bytecode::Op::Add const& op)
  441. {
  442. load_vm_register(ARG1, op.lhs());
  443. load_vm_register(ARG2, Bytecode::Register::accumulator());
  444. Assembler::Label end {};
  445. Assembler::Label slow_case {};
  446. branch_if_both_int32(ARG1, ARG2, [&] {
  447. // GPR0 = ARG1 + ARG2 (32-bit)
  448. // if (overflow) goto slow_case;
  449. m_assembler.mov(
  450. Assembler::Operand::Register(GPR0),
  451. Assembler::Operand::Register(ARG1));
  452. m_assembler.add32(
  453. Assembler::Operand::Register(GPR0),
  454. Assembler::Operand::Register(ARG2),
  455. slow_case);
  456. // accumulator = GPR0 | SHIFTED_INT32_TAG;
  457. m_assembler.mov(
  458. Assembler::Operand::Register(GPR1),
  459. Assembler::Operand::Imm(SHIFTED_INT32_TAG));
  460. m_assembler.bitwise_or(
  461. Assembler::Operand::Register(GPR0),
  462. Assembler::Operand::Register(GPR1));
  463. store_vm_register(Bytecode::Register::accumulator(), GPR0);
  464. m_assembler.jump(end);
  465. });
  466. slow_case.link(m_assembler);
  467. native_call((void*)cxx_add);
  468. store_vm_register(Bytecode::Register::accumulator(), RET);
  469. check_exception();
  470. end.link(m_assembler);
  471. }
  472. static Value cxx_less_than(VM& vm, Value lhs, Value rhs)
  473. {
  474. return TRY_OR_SET_EXCEPTION(less_than(vm, lhs, rhs));
  475. }
  476. void Compiler::compile_less_than(Bytecode::Op::LessThan const& op)
  477. {
  478. load_vm_register(ARG1, op.lhs());
  479. load_vm_register(ARG2, Bytecode::Register::accumulator());
  480. Assembler::Label end {};
  481. branch_if_both_int32(ARG1, ARG2, [&] {
  482. // if (ARG1 < ARG2) return true;
  483. // else return false;
  484. Assembler::Label true_case {};
  485. m_assembler.sign_extend_32_to_64_bits(ARG1);
  486. m_assembler.sign_extend_32_to_64_bits(ARG2);
  487. m_assembler.jump_if(
  488. Assembler::Operand::Register(ARG1),
  489. Assembler::Condition::SignedLessThan,
  490. Assembler::Operand::Register(ARG2),
  491. true_case);
  492. m_assembler.mov(
  493. Assembler::Operand::Register(GPR0),
  494. Assembler::Operand::Imm(Value(false).encoded()));
  495. store_vm_register(Bytecode::Register::accumulator(), GPR0);
  496. m_assembler.jump(end);
  497. true_case.link(m_assembler);
  498. m_assembler.mov(
  499. Assembler::Operand::Register(GPR0),
  500. Assembler::Operand::Imm(Value(true).encoded()));
  501. store_vm_register(Bytecode::Register::accumulator(), GPR0);
  502. m_assembler.jump(end);
  503. });
  504. native_call((void*)cxx_less_than);
  505. store_vm_register(Bytecode::Register::accumulator(), RET);
  506. check_exception();
  507. end.link(m_assembler);
  508. }
  509. static ThrowCompletionOr<Value> not_(VM&, Value value)
  510. {
  511. return Value(!value.to_boolean());
  512. }
  513. static ThrowCompletionOr<Value> typeof_(VM& vm, Value value)
  514. {
  515. return PrimitiveString::create(vm, value.typeof());
  516. }
  517. # define DO_COMPILE_COMMON_UNARY_OP(TitleCaseName, snake_case_name) \
  518. static Value cxx_##snake_case_name(VM& vm, Value value) \
  519. { \
  520. return TRY_OR_SET_EXCEPTION(snake_case_name(vm, value)); \
  521. } \
  522. \
  523. void Compiler::compile_##snake_case_name(Bytecode::Op::TitleCaseName const&) \
  524. { \
  525. load_vm_register(ARG1, Bytecode::Register::accumulator()); \
  526. native_call((void*)cxx_##snake_case_name); \
  527. store_vm_register(Bytecode::Register::accumulator(), RET); \
  528. check_exception(); \
  529. }
  530. JS_ENUMERATE_COMMON_UNARY_OPS(DO_COMPILE_COMMON_UNARY_OP)
  531. # undef DO_COMPILE_COMMON_UNARY_OP
  532. void Compiler::compile_return(Bytecode::Op::Return const&)
  533. {
  534. load_vm_register(GPR0, Bytecode::Register::accumulator());
  535. // check for finalizer
  536. // if (!unwind_context.valid) goto normal_return;
  537. Assembler::Label normal_return {};
  538. m_assembler.mov(
  539. Assembler::Operand::Register(GPR1),
  540. Assembler::Operand::Mem64BaseAndOffset(UNWIND_CONTEXT_BASE, 0));
  541. m_assembler.jump_if(
  542. Assembler::Operand::Register(GPR1),
  543. Assembler::Condition::EqualTo,
  544. Assembler::Operand::Imm(0),
  545. normal_return);
  546. // if (!unwind_context.finalizer) goto normal_return;
  547. m_assembler.mov(
  548. Assembler::Operand::Register(GPR1),
  549. Assembler::Operand::Mem64BaseAndOffset(UNWIND_CONTEXT_BASE, 16));
  550. m_assembler.jump_if(
  551. Assembler::Operand::Register(GPR1),
  552. Assembler::Condition::EqualTo,
  553. Assembler::Operand::Imm(0),
  554. normal_return);
  555. store_vm_register(Bytecode::Register::saved_return_value(), GPR0);
  556. m_assembler.jump(Assembler::Operand::Register(GPR1));
  557. // normal_return:
  558. normal_return.link(m_assembler);
  559. store_vm_register(Bytecode::Register::return_value(), GPR0);
  560. jump_to_exit();
  561. }
  562. static Value cxx_new_string(VM& vm, DeprecatedString const& string)
  563. {
  564. return PrimitiveString::create(vm, string);
  565. }
  566. void Compiler::compile_new_string(Bytecode::Op::NewString const& op)
  567. {
  568. auto const& string = m_bytecode_executable.string_table->get(op.index());
  569. m_assembler.mov(
  570. Assembler::Operand::Register(ARG1),
  571. Assembler::Operand::Imm(bit_cast<u64>(&string)));
  572. native_call((void*)cxx_new_string);
  573. store_vm_register(Bytecode::Register::accumulator(), RET);
  574. }
  575. void Compiler::compile_new_regexp(Bytecode::Op::NewRegExp const& op)
  576. {
  577. auto const& parsed_regex = m_bytecode_executable.regex_table->get(op.regex_index());
  578. auto const& pattern = m_bytecode_executable.string_table->get(op.source_index());
  579. auto const& flags = m_bytecode_executable.string_table->get(op.flags_index());
  580. m_assembler.mov(
  581. Assembler::Operand::Register(ARG1),
  582. Assembler::Operand::Imm(bit_cast<u64>(&parsed_regex)));
  583. m_assembler.mov(
  584. Assembler::Operand::Register(ARG2),
  585. Assembler::Operand::Imm(bit_cast<u64>(&pattern)));
  586. m_assembler.mov(
  587. Assembler::Operand::Register(ARG3),
  588. Assembler::Operand::Imm(bit_cast<u64>(&flags)));
  589. native_call((void*)Bytecode::new_regexp);
  590. store_vm_register(Bytecode::Register::accumulator(), RET);
  591. }
  592. static Value cxx_new_bigint(VM& vm, Crypto::SignedBigInteger const& bigint)
  593. {
  594. return BigInt::create(vm, bigint);
  595. }
  596. void Compiler::compile_new_bigint(Bytecode::Op::NewBigInt const& op)
  597. {
  598. m_assembler.mov(
  599. Assembler::Operand::Register(ARG1),
  600. Assembler::Operand::Imm(bit_cast<u64>(&op.bigint())));
  601. native_call((void*)cxx_new_bigint);
  602. store_vm_register(Bytecode::Register::accumulator(), RET);
  603. }
  604. static Value cxx_new_object(VM& vm)
  605. {
  606. auto& realm = *vm.current_realm();
  607. return Object::create(realm, realm.intrinsics().object_prototype());
  608. }
  609. void Compiler::compile_new_object(Bytecode::Op::NewObject const&)
  610. {
  611. native_call((void*)cxx_new_object);
  612. store_vm_register(Bytecode::Register::accumulator(), RET);
  613. }
  614. static Value cxx_new_array(VM& vm, size_t element_count, u32 first_register_index)
  615. {
  616. auto& realm = *vm.current_realm();
  617. auto array = MUST(Array::create(realm, 0));
  618. for (size_t i = 0; i < element_count; ++i) {
  619. auto& value = vm.bytecode_interpreter().reg(Bytecode::Register(first_register_index + i));
  620. array->indexed_properties().put(i, value, default_attributes);
  621. }
  622. return array;
  623. }
  624. void Compiler::compile_new_array(Bytecode::Op::NewArray const& op)
  625. {
  626. m_assembler.mov(
  627. Assembler::Operand::Register(ARG1),
  628. Assembler::Operand::Imm(op.element_count()));
  629. m_assembler.mov(
  630. Assembler::Operand::Register(ARG2),
  631. Assembler::Operand::Imm(op.element_count() ? op.start().index() : 0));
  632. native_call((void*)cxx_new_array);
  633. store_vm_register(Bytecode::Register::accumulator(), RET);
  634. }
  635. void Compiler::compile_new_function(Bytecode::Op::NewFunction const& op)
  636. {
  637. m_assembler.mov(
  638. Assembler::Operand::Register(ARG1),
  639. Assembler::Operand::Imm(bit_cast<u64>(&op.function_node())));
  640. m_assembler.mov(
  641. Assembler::Operand::Register(ARG2),
  642. Assembler::Operand::Imm(bit_cast<u64>(&op.lhs_name())));
  643. m_assembler.mov(
  644. Assembler::Operand::Register(ARG3),
  645. Assembler::Operand::Imm(bit_cast<u64>(&op.home_object())));
  646. native_call((void*)Bytecode::new_function);
  647. store_vm_register(Bytecode::Register::accumulator(), RET);
  648. }
  649. static Value cxx_new_class(VM& vm, ClassExpression const& class_expression, Optional<Bytecode::IdentifierTableIndex> const& lhs_name)
  650. {
  651. return TRY_OR_SET_EXCEPTION(Bytecode::new_class(vm, class_expression, lhs_name));
  652. }
  653. void Compiler::compile_new_class(Bytecode::Op::NewClass const& op)
  654. {
  655. m_assembler.mov(
  656. Assembler::Operand::Register(ARG1),
  657. Assembler::Operand::Imm(bit_cast<u64>(&op.class_expression())));
  658. m_assembler.mov(
  659. Assembler::Operand::Register(ARG2),
  660. Assembler::Operand::Imm(bit_cast<u64>(&op.lhs_name())));
  661. native_call((void*)cxx_new_class);
  662. store_vm_register(Bytecode::Register::accumulator(), RET);
  663. }
  664. static Value cxx_get_by_id(VM& vm, Value base, Bytecode::IdentifierTableIndex property, u32 cache_index)
  665. {
  666. return TRY_OR_SET_EXCEPTION(Bytecode::get_by_id(vm.bytecode_interpreter(), property, base, base, cache_index));
  667. }
  668. void Compiler::compile_get_by_id(Bytecode::Op::GetById const& op)
  669. {
  670. load_vm_register(ARG1, Bytecode::Register::accumulator());
  671. m_assembler.mov(
  672. Assembler::Operand::Register(ARG2),
  673. Assembler::Operand::Imm(op.property().value()));
  674. m_assembler.mov(
  675. Assembler::Operand::Register(ARG3),
  676. Assembler::Operand::Imm(op.cache_index()));
  677. native_call((void*)cxx_get_by_id);
  678. store_vm_register(Bytecode::Register::accumulator(), RET);
  679. check_exception();
  680. }
  681. static Value cxx_get_by_value(VM& vm, Value base, Value property)
  682. {
  683. return TRY_OR_SET_EXCEPTION(Bytecode::get_by_value(vm.bytecode_interpreter(), base, property));
  684. }
  685. void Compiler::compile_get_by_value(Bytecode::Op::GetByValue const& op)
  686. {
  687. load_vm_register(ARG1, op.base());
  688. load_vm_register(ARG2, Bytecode::Register::accumulator());
  689. native_call((void*)cxx_get_by_value);
  690. store_vm_register(Bytecode::Register::accumulator(), RET);
  691. check_exception();
  692. }
  693. static Value cxx_get_global(VM& vm, Bytecode::IdentifierTableIndex identifier, u32 cache_index)
  694. {
  695. return TRY_OR_SET_EXCEPTION(Bytecode::get_global(vm.bytecode_interpreter(), identifier, cache_index));
  696. }
  697. void Compiler::compile_get_global(Bytecode::Op::GetGlobal const& op)
  698. {
  699. m_assembler.mov(
  700. Assembler::Operand::Register(ARG1),
  701. Assembler::Operand::Imm(op.identifier().value()));
  702. m_assembler.mov(
  703. Assembler::Operand::Register(ARG2),
  704. Assembler::Operand::Imm(op.cache_index()));
  705. native_call((void*)cxx_get_global);
  706. store_vm_register(Bytecode::Register::accumulator(), RET);
  707. check_exception();
  708. }
  709. static Value cxx_get_variable(VM& vm, DeprecatedFlyString const& name, u32 cache_index)
  710. {
  711. return TRY_OR_SET_EXCEPTION(Bytecode::get_variable(vm.bytecode_interpreter(), name, cache_index));
  712. }
  713. void Compiler::compile_get_variable(Bytecode::Op::GetVariable const& op)
  714. {
  715. m_assembler.mov(
  716. Assembler::Operand::Register(ARG1),
  717. Assembler::Operand::Imm(bit_cast<u64>(&m_bytecode_executable.get_identifier(op.identifier()))));
  718. m_assembler.mov(
  719. Assembler::Operand::Register(ARG2),
  720. Assembler::Operand::Imm(op.cache_index()));
  721. native_call((void*)cxx_get_variable);
  722. store_vm_register(Bytecode::Register::accumulator(), RET);
  723. check_exception();
  724. }
  725. static Value cxx_get_callee_and_this_from_environment(VM& vm, DeprecatedFlyString const& name, u32 cache_index, Bytecode::Register callee_reg, Bytecode::Register this_reg)
  726. {
  727. auto& bytecode_interpreter = vm.bytecode_interpreter();
  728. auto callee_and_this = TRY_OR_SET_EXCEPTION(Bytecode::get_callee_and_this_from_environment(
  729. bytecode_interpreter,
  730. name,
  731. cache_index));
  732. bytecode_interpreter.reg(callee_reg) = callee_and_this.callee;
  733. bytecode_interpreter.reg(this_reg) = callee_and_this.this_value;
  734. return {};
  735. }
  736. void Compiler::compile_get_callee_and_this_from_environment(Bytecode::Op::GetCalleeAndThisFromEnvironment const& op)
  737. {
  738. m_assembler.mov(
  739. Assembler::Operand::Register(ARG1),
  740. Assembler::Operand::Imm(bit_cast<u64>(&m_bytecode_executable.get_identifier(op.identifier()))));
  741. m_assembler.mov(
  742. Assembler::Operand::Register(ARG2),
  743. Assembler::Operand::Imm(op.cache_index()));
  744. m_assembler.mov(
  745. Assembler::Operand::Register(ARG3),
  746. Assembler::Operand::Imm(op.callee().index()));
  747. m_assembler.mov(
  748. Assembler::Operand::Register(ARG4),
  749. Assembler::Operand::Imm(op.this_().index()));
  750. native_call((void*)cxx_get_callee_and_this_from_environment);
  751. check_exception();
  752. }
  753. static Value cxx_to_numeric(VM& vm, Value value)
  754. {
  755. return TRY_OR_SET_EXCEPTION(value.to_numeric(vm));
  756. }
  757. void Compiler::compile_to_numeric(Bytecode::Op::ToNumeric const&)
  758. {
  759. load_vm_register(ARG1, Bytecode::Register::accumulator());
  760. native_call((void*)cxx_to_numeric);
  761. store_vm_register(Bytecode::Register::accumulator(), RET);
  762. check_exception();
  763. }
  764. static Value cxx_resolve_this_binding(VM& vm)
  765. {
  766. auto this_value = TRY_OR_SET_EXCEPTION(vm.resolve_this_binding());
  767. vm.bytecode_interpreter().reg(Bytecode::Register::this_value()) = this_value;
  768. return this_value;
  769. }
  770. void Compiler::compile_resolve_this_binding(Bytecode::Op::ResolveThisBinding const&)
  771. {
  772. // OPTIMIZATION: We cache the `this` value in a special VM register.
  773. // So first we check if the cache is non-empty, and if so,
  774. // we can avoid calling out to C++ at all. :^)
  775. load_vm_register(GPR0, Bytecode::Register::this_value());
  776. m_assembler.mov(
  777. Assembler::Operand::Register(GPR1),
  778. Assembler::Operand::Imm(Value().encoded()));
  779. Assembler::Label slow_case {};
  780. m_assembler.jump_if(
  781. Assembler::Operand::Register(GPR0),
  782. Assembler::Condition::EqualTo,
  783. Assembler::Operand::Register(GPR1),
  784. slow_case);
  785. // Fast case: We have a cached `this` value!
  786. store_vm_register(Bytecode::Register::accumulator(), GPR0);
  787. auto end = m_assembler.jump();
  788. slow_case.link(m_assembler);
  789. native_call((void*)cxx_resolve_this_binding);
  790. store_vm_register(Bytecode::Register::accumulator(), RET);
  791. check_exception();
  792. end.link(m_assembler);
  793. }
  794. static Value cxx_put_by_id(VM& vm, Value base, Bytecode::IdentifierTableIndex property, Value value, Bytecode::Op::PropertyKind kind)
  795. {
  796. PropertyKey name = vm.bytecode_interpreter().current_executable().get_identifier(property);
  797. TRY_OR_SET_EXCEPTION(Bytecode::put_by_property_key(vm, base, base, value, name, kind));
  798. vm.bytecode_interpreter().accumulator() = value;
  799. return {};
  800. }
  801. void Compiler::compile_put_by_id(Bytecode::Op::PutById const& op)
  802. {
  803. load_vm_register(ARG1, op.base());
  804. m_assembler.mov(
  805. Assembler::Operand::Register(ARG2),
  806. Assembler::Operand::Imm(op.property().value()));
  807. load_vm_register(ARG3, Bytecode::Register::accumulator());
  808. m_assembler.mov(
  809. Assembler::Operand::Register(ARG4),
  810. Assembler::Operand::Imm(to_underlying(op.kind())));
  811. native_call((void*)cxx_put_by_id);
  812. check_exception();
  813. }
  814. static Value cxx_put_by_value(VM& vm, Value base, Value property, Value value, Bytecode::Op::PropertyKind kind)
  815. {
  816. TRY_OR_SET_EXCEPTION(Bytecode::put_by_value(vm, base, property, value, kind));
  817. vm.bytecode_interpreter().accumulator() = value;
  818. return {};
  819. }
  820. void Compiler::compile_put_by_value(Bytecode::Op::PutByValue const& op)
  821. {
  822. load_vm_register(ARG1, op.base());
  823. load_vm_register(ARG2, op.property());
  824. load_vm_register(ARG3, Bytecode::Register::accumulator());
  825. m_assembler.mov(
  826. Assembler::Operand::Register(ARG4),
  827. Assembler::Operand::Imm(to_underlying(op.kind())));
  828. native_call((void*)cxx_put_by_value);
  829. check_exception();
  830. }
  831. static Value cxx_call(VM& vm, Value callee, u32 first_argument_index, u32 argument_count, Value this_value, Bytecode::Op::CallType call_type, Optional<Bytecode::StringTableIndex> const& expression_string)
  832. {
  833. TRY_OR_SET_EXCEPTION(throw_if_needed_for_call(vm.bytecode_interpreter(), callee, call_type, expression_string));
  834. MarkedVector<Value> argument_values(vm.heap());
  835. argument_values.ensure_capacity(argument_count);
  836. for (u32 i = 0; i < argument_count; ++i) {
  837. argument_values.unchecked_append(vm.bytecode_interpreter().reg(Bytecode::Register { first_argument_index + i }));
  838. }
  839. return TRY_OR_SET_EXCEPTION(perform_call(vm.bytecode_interpreter(), this_value, call_type, callee, move(argument_values)));
  840. }
  841. void Compiler::compile_call(Bytecode::Op::Call const& op)
  842. {
  843. load_vm_register(ARG1, op.callee());
  844. m_assembler.mov(
  845. Assembler::Operand::Register(ARG2),
  846. Assembler::Operand::Imm(op.first_argument().index()));
  847. m_assembler.mov(
  848. Assembler::Operand::Register(ARG3),
  849. Assembler::Operand::Imm(op.argument_count()));
  850. load_vm_register(ARG4, op.this_value());
  851. m_assembler.mov(
  852. Assembler::Operand::Register(ARG5),
  853. Assembler::Operand::Imm(to_underlying(op.call_type())));
  854. m_assembler.mov(
  855. Assembler::Operand::Register(GPR0),
  856. Assembler::Operand::Imm(bit_cast<u64>(&op.expression_string())));
  857. native_call((void*)cxx_call, { Assembler::Operand::Register(GPR0) });
  858. store_vm_register(Bytecode::Register::accumulator(), RET);
  859. check_exception();
  860. }
  861. static Value cxx_call_with_argument_array(VM& vm, Value callee, Value this_value, Bytecode::Op::CallType call_type, Optional<Bytecode::StringTableIndex> const& expression_string)
  862. {
  863. TRY_OR_SET_EXCEPTION(throw_if_needed_for_call(vm.bytecode_interpreter(), callee, call_type, expression_string));
  864. auto argument_values = argument_list_evaluation(vm.bytecode_interpreter());
  865. return TRY_OR_SET_EXCEPTION(perform_call(vm.bytecode_interpreter(), this_value, call_type, callee, move(argument_values)));
  866. }
  867. void Compiler::compile_call_with_argument_array(Bytecode::Op::CallWithArgumentArray const& op)
  868. {
  869. load_vm_register(ARG1, op.callee());
  870. load_vm_register(ARG2, op.this_value());
  871. m_assembler.mov(
  872. Assembler::Operand::Register(ARG3),
  873. Assembler::Operand::Imm(to_underlying(op.call_type())));
  874. m_assembler.mov(
  875. Assembler::Operand::Register(ARG4),
  876. Assembler::Operand::Imm(bit_cast<u64>(&op.expression_string())));
  877. native_call((void*)cxx_call_with_argument_array);
  878. store_vm_register(Bytecode::Register::accumulator(), RET);
  879. check_exception();
  880. }
  881. static Value cxx_typeof_variable(VM& vm, DeprecatedFlyString const& identifier)
  882. {
  883. return TRY_OR_SET_EXCEPTION(Bytecode::typeof_variable(vm, identifier));
  884. }
  885. void Compiler::compile_typeof_variable(Bytecode::Op::TypeofVariable const& op)
  886. {
  887. m_assembler.mov(
  888. Assembler::Operand::Register(ARG1),
  889. Assembler::Operand::Imm(bit_cast<u64>(&m_bytecode_executable.get_identifier(op.identifier().value()))));
  890. native_call((void*)cxx_typeof_variable);
  891. store_vm_register(Bytecode::Register::accumulator(), RET);
  892. check_exception();
  893. }
  894. static Value cxx_create_variable(
  895. VM& vm,
  896. DeprecatedFlyString const& name,
  897. Bytecode::Op::EnvironmentMode mode,
  898. bool is_global,
  899. bool is_immutable,
  900. bool is_strict)
  901. {
  902. TRY_OR_SET_EXCEPTION(Bytecode::create_variable(vm, name, mode, is_global, is_immutable, is_strict));
  903. return {};
  904. }
  905. void Compiler::compile_create_variable(Bytecode::Op::CreateVariable const& op)
  906. {
  907. m_assembler.mov(
  908. Assembler::Operand::Register(ARG1),
  909. Assembler::Operand::Imm(bit_cast<u64>(&m_bytecode_executable.get_identifier(op.identifier().value()))));
  910. m_assembler.mov(
  911. Assembler::Operand::Register(ARG2),
  912. Assembler::Operand::Imm(to_underlying(op.mode())));
  913. m_assembler.mov(
  914. Assembler::Operand::Register(ARG3),
  915. Assembler::Operand::Imm(static_cast<u64>(op.is_global())));
  916. m_assembler.mov(
  917. Assembler::Operand::Register(ARG4),
  918. Assembler::Operand::Imm(static_cast<u64>(op.is_immutable())));
  919. m_assembler.mov(
  920. Assembler::Operand::Register(ARG5),
  921. Assembler::Operand::Imm(static_cast<u64>(op.is_strict())));
  922. native_call((void*)cxx_create_variable);
  923. check_exception();
  924. }
  925. static Value cxx_set_variable(
  926. VM& vm,
  927. DeprecatedFlyString const& identifier,
  928. Value value,
  929. Bytecode::Op::EnvironmentMode environment_mode,
  930. Bytecode::Op::SetVariable::InitializationMode initialization_mode)
  931. {
  932. TRY_OR_SET_EXCEPTION(Bytecode::set_variable(vm, identifier, value, environment_mode, initialization_mode));
  933. return {};
  934. }
  935. void Compiler::compile_set_variable(Bytecode::Op::SetVariable const& op)
  936. {
  937. m_assembler.mov(
  938. Assembler::Operand::Register(ARG1),
  939. Assembler::Operand::Imm(bit_cast<u64>(&m_bytecode_executable.get_identifier(op.identifier().value()))));
  940. load_vm_register(ARG2, Bytecode::Register::accumulator());
  941. m_assembler.mov(
  942. Assembler::Operand::Register(ARG3),
  943. Assembler::Operand::Imm(to_underlying(op.mode())));
  944. m_assembler.mov(
  945. Assembler::Operand::Register(ARG4),
  946. Assembler::Operand::Imm(to_underlying(op.initialization_mode())));
  947. native_call((void*)cxx_set_variable);
  948. check_exception();
  949. }
  950. void Compiler::compile_continue_pending_unwind(Bytecode::Op::ContinuePendingUnwind const& op)
  951. {
  952. // re-throw the exception if we reached the end of the finally block and there was no catch block to handle it
  953. check_exception();
  954. // if (!saved_return_value.is_empty()) goto resume_block;
  955. load_vm_register(GPR0, Bytecode::Register::saved_return_value());
  956. m_assembler.mov(Assembler::Operand::Register(GPR1), Assembler::Operand::Imm(Value().encoded()));
  957. m_assembler.jump_if(
  958. Assembler::Operand::Register(GPR0),
  959. Assembler::Condition::NotEqualTo,
  960. Assembler::Operand::Register(GPR1),
  961. label_for(op.resume_target().block()));
  962. // finish the pending return from the try block
  963. store_vm_register(Bytecode::Register::return_value(), GPR0);
  964. jump_to_exit();
  965. }
  966. static void cxx_create_lexical_environment(VM& vm)
  967. {
  968. auto make_and_swap_envs = [&](auto& old_environment) {
  969. GCPtr<Environment> environment = new_declarative_environment(*old_environment).ptr();
  970. swap(old_environment, environment);
  971. return environment;
  972. };
  973. vm.bytecode_interpreter().saved_lexical_environment_stack().append(make_and_swap_envs(vm.running_execution_context().lexical_environment));
  974. }
  975. void Compiler::compile_create_lexical_environment(Bytecode::Op::CreateLexicalEnvironment const&)
  976. {
  977. native_call((void*)cxx_create_lexical_environment);
  978. }
  979. static void cxx_leave_lexical_environment(VM& vm)
  980. {
  981. vm.running_execution_context().lexical_environment = vm.bytecode_interpreter().saved_lexical_environment_stack().take_last();
  982. }
  983. void Compiler::compile_leave_lexical_environment(Bytecode::Op::LeaveLexicalEnvironment const&)
  984. {
  985. native_call((void*)cxx_leave_lexical_environment);
  986. }
  987. static Value cxx_concat_string(VM& vm, Value lhs, Value rhs)
  988. {
  989. auto string = TRY_OR_SET_EXCEPTION(rhs.to_primitive_string(vm));
  990. return PrimitiveString::create(vm, lhs.as_string(), string);
  991. }
  992. void Compiler::compile_concat_string(Bytecode::Op::ConcatString const& op)
  993. {
  994. load_vm_register(ARG1, op.lhs());
  995. load_vm_register(ARG2, Bytecode::Register::accumulator());
  996. native_call((void*)cxx_concat_string);
  997. store_vm_register(op.lhs(), RET);
  998. check_exception();
  999. }
  1000. static void cxx_block_declaration_instantiation(VM& vm, ScopeNode const& scope_node)
  1001. {
  1002. auto old_environment = vm.running_execution_context().lexical_environment;
  1003. vm.bytecode_interpreter().saved_lexical_environment_stack().append(old_environment);
  1004. vm.running_execution_context().lexical_environment = new_declarative_environment(*old_environment);
  1005. scope_node.block_declaration_instantiation(vm, vm.running_execution_context().lexical_environment);
  1006. }
  1007. void Compiler::compile_block_declaration_instantiation(Bytecode::Op::BlockDeclarationInstantiation const& op)
  1008. {
  1009. m_assembler.mov(
  1010. Assembler::Operand::Register(ARG1),
  1011. Assembler::Operand::Imm(bit_cast<u64>(&op.scope_node())));
  1012. native_call((void*)cxx_block_declaration_instantiation);
  1013. }
  1014. static Value cxx_super_call_with_argument_array(VM& vm, Value argument_array, bool is_synthetic)
  1015. {
  1016. TRY_OR_SET_EXCEPTION(Bytecode::super_call_with_argument_array(vm, argument_array, is_synthetic));
  1017. return {};
  1018. }
  1019. void Compiler::compile_super_call_with_argument_array(Bytecode::Op::SuperCallWithArgumentArray const& op)
  1020. {
  1021. load_vm_register(ARG1, Bytecode::Register::accumulator());
  1022. m_assembler.mov(
  1023. Assembler::Operand::Register(ARG2),
  1024. Assembler::Operand::Imm(static_cast<u64>(op.is_synthetic())));
  1025. native_call((void*)cxx_super_call_with_argument_array);
  1026. store_vm_register(Bytecode::Register::accumulator(), RET);
  1027. check_exception();
  1028. }
  1029. static Value cxx_get_iterator(VM& vm, Value value, IteratorHint hint)
  1030. {
  1031. auto iterator = TRY_OR_SET_EXCEPTION(get_iterator(vm, value, hint));
  1032. return Bytecode::iterator_to_object(vm, iterator);
  1033. }
  1034. void Compiler::compile_get_iterator(Bytecode::Op::GetIterator const& op)
  1035. {
  1036. load_vm_register(ARG1, Bytecode::Register::accumulator());
  1037. m_assembler.mov(
  1038. Assembler::Operand::Register(ARG2),
  1039. Assembler::Operand::Imm(to_underlying(op.hint())));
  1040. native_call((void*)cxx_get_iterator);
  1041. store_vm_register(Bytecode::Register::accumulator(), RET);
  1042. check_exception();
  1043. }
  1044. static Value cxx_iterator_next(VM& vm, Value iterator)
  1045. {
  1046. auto iterator_object = TRY_OR_SET_EXCEPTION(iterator.to_object(vm));
  1047. auto iterator_record = Bytecode::object_to_iterator(vm, iterator_object);
  1048. return TRY_OR_SET_EXCEPTION(iterator_next(vm, iterator_record));
  1049. }
  1050. void Compiler::compile_iterator_next(Bytecode::Op::IteratorNext const&)
  1051. {
  1052. load_vm_register(ARG1, Bytecode::Register::accumulator());
  1053. native_call((void*)cxx_iterator_next);
  1054. store_vm_register(Bytecode::Register::accumulator(), RET);
  1055. check_exception();
  1056. }
  1057. static Value cxx_iterator_result_done(VM& vm, Value iterator)
  1058. {
  1059. auto iterator_result = TRY_OR_SET_EXCEPTION(iterator.to_object(vm));
  1060. return Value(TRY_OR_SET_EXCEPTION(iterator_complete(vm, iterator_result)));
  1061. }
  1062. void Compiler::compile_iterator_result_done(Bytecode::Op::IteratorResultDone const&)
  1063. {
  1064. load_vm_register(ARG1, Bytecode::Register::accumulator());
  1065. native_call((void*)cxx_iterator_result_done);
  1066. store_vm_register(Bytecode::Register::accumulator(), RET);
  1067. check_exception();
  1068. }
  1069. static Value cxx_throw_if_not_object(VM& vm, Value value)
  1070. {
  1071. if (!value.is_object())
  1072. TRY_OR_SET_EXCEPTION(vm.throw_completion<TypeError>(ErrorType::NotAnObject, value.to_string_without_side_effects()));
  1073. return {};
  1074. }
  1075. void Compiler::compile_throw_if_not_object(Bytecode::Op::ThrowIfNotObject const&)
  1076. {
  1077. load_vm_register(ARG1, Bytecode::Register::accumulator());
  1078. native_call((void*)cxx_throw_if_not_object);
  1079. check_exception();
  1080. }
  1081. static Value cxx_throw_if_nullish(VM& vm, Value value)
  1082. {
  1083. if (value.is_nullish())
  1084. TRY_OR_SET_EXCEPTION(vm.throw_completion<TypeError>(ErrorType::NotObjectCoercible, value.to_string_without_side_effects()));
  1085. return {};
  1086. }
  1087. void Compiler::compile_throw_if_nullish(Bytecode::Op::ThrowIfNullish const&)
  1088. {
  1089. load_vm_register(ARG1, Bytecode::Register::accumulator());
  1090. native_call((void*)cxx_throw_if_nullish);
  1091. check_exception();
  1092. }
  1093. static Value cxx_iterator_result_value(VM& vm, Value iterator)
  1094. {
  1095. auto iterator_result = TRY_OR_SET_EXCEPTION(iterator.to_object(vm));
  1096. return TRY_OR_SET_EXCEPTION(iterator_value(vm, iterator_result));
  1097. }
  1098. void Compiler::compile_iterator_result_value(Bytecode::Op::IteratorResultValue const&)
  1099. {
  1100. load_vm_register(ARG1, Bytecode::Register::accumulator());
  1101. native_call((void*)cxx_iterator_result_value);
  1102. store_vm_register(Bytecode::Register::accumulator(), RET);
  1103. check_exception();
  1104. }
  1105. static Value cxx_iterator_close(VM& vm, Value iterator, Completion::Type completion_type, Optional<Value> const& completion_value)
  1106. {
  1107. auto iterator_object = TRY_OR_SET_EXCEPTION(iterator.to_object(vm));
  1108. auto iterator_record = Bytecode::object_to_iterator(vm, iterator_object);
  1109. // FIXME: Return the value of the resulting completion. (Note that m_completion_value can be empty!)
  1110. TRY_OR_SET_EXCEPTION(iterator_close(vm, iterator_record, Completion { completion_type, completion_value, {} }));
  1111. return {};
  1112. }
  1113. void Compiler::compile_iterator_close(Bytecode::Op::IteratorClose const& op)
  1114. {
  1115. load_vm_register(ARG1, Bytecode::Register::accumulator());
  1116. m_assembler.mov(
  1117. Assembler::Operand::Register(ARG2),
  1118. Assembler::Operand::Imm(to_underlying(op.completion_type())));
  1119. m_assembler.mov(
  1120. Assembler::Operand::Register(ARG3),
  1121. Assembler::Operand::Imm(bit_cast<u64>(&op.completion_value())));
  1122. native_call((void*)cxx_iterator_close);
  1123. check_exception();
  1124. }
  1125. static Value iterator_to_array(VM& vm, Value iterator)
  1126. {
  1127. return TRY_OR_SET_EXCEPTION(Bytecode::iterator_to_array(vm, iterator));
  1128. }
  1129. void Compiler::compile_iterator_to_array(Bytecode::Op::IteratorToArray const&)
  1130. {
  1131. load_vm_register(ARG1, Bytecode::Register::accumulator());
  1132. native_call((void*)iterator_to_array);
  1133. store_vm_register(Bytecode::Register::accumulator(), RET);
  1134. check_exception();
  1135. }
  1136. static Value cxx_append(VM& vm, Value lhs, Value rhs, bool is_spread)
  1137. {
  1138. TRY_OR_SET_EXCEPTION(Bytecode::append(vm, lhs, rhs, is_spread));
  1139. return {};
  1140. }
  1141. void Compiler::compile_append(Bytecode::Op::Append const& op)
  1142. {
  1143. load_vm_register(ARG1, op.lhs());
  1144. load_vm_register(ARG2, Bytecode::Register::accumulator());
  1145. m_assembler.mov(
  1146. Assembler::Operand::Register(ARG3),
  1147. Assembler::Operand::Imm(static_cast<u64>(op.is_spread())));
  1148. native_call((void*)cxx_append);
  1149. check_exception();
  1150. }
  1151. static Value cxx_delete_by_id(VM& vm, Value base, Bytecode::IdentifierTableIndex property)
  1152. {
  1153. return TRY_OR_SET_EXCEPTION(Bytecode::delete_by_id(vm.bytecode_interpreter(), base, property));
  1154. }
  1155. void Compiler::compile_delete_by_id(Bytecode::Op::DeleteById const& op)
  1156. {
  1157. load_vm_register(ARG1, Bytecode::Register::accumulator());
  1158. m_assembler.mov(
  1159. Assembler::Operand::Register(ARG2),
  1160. Assembler::Operand::Imm(op.property().value()));
  1161. native_call((void*)cxx_delete_by_id);
  1162. store_vm_register(Bytecode::Register::accumulator(), RET);
  1163. check_exception();
  1164. }
  1165. static Value cxx_delete_by_value(VM& vm, Value base_value, Value property_key_value)
  1166. {
  1167. return TRY_OR_SET_EXCEPTION(Bytecode::delete_by_value(vm.bytecode_interpreter(), base_value, property_key_value));
  1168. }
  1169. void Compiler::compile_delete_by_value(Bytecode::Op::DeleteByValue const& op)
  1170. {
  1171. load_vm_register(ARG1, op.base());
  1172. load_vm_register(ARG2, Bytecode::Register::accumulator());
  1173. native_call((void*)cxx_delete_by_value);
  1174. store_vm_register(Bytecode::Register::accumulator(), RET);
  1175. check_exception();
  1176. }
  1177. static Value cxx_delete_by_value_with_this(VM& vm, Value base_value, Value property_key_value, Value this_value)
  1178. {
  1179. return TRY_OR_SET_EXCEPTION(Bytecode::delete_by_value_with_this(vm.bytecode_interpreter(), base_value, property_key_value, this_value));
  1180. }
  1181. void Compiler::compile_delete_by_value_with_this(Bytecode::Op::DeleteByValueWithThis const& op)
  1182. {
  1183. load_vm_register(ARG1, op.base());
  1184. load_vm_register(ARG2, Bytecode::Register::accumulator());
  1185. load_vm_register(ARG3, op.this_value());
  1186. native_call((void*)cxx_delete_by_value_with_this);
  1187. store_vm_register(Bytecode::Register::accumulator(), RET);
  1188. check_exception();
  1189. }
  1190. static Value cxx_get_object_property_iterator(VM& vm, Value object)
  1191. {
  1192. return TRY_OR_SET_EXCEPTION(Bytecode::get_object_property_iterator(vm, object));
  1193. }
  1194. void Compiler::compile_get_object_property_iterator(Bytecode::Op::GetObjectPropertyIterator const&)
  1195. {
  1196. load_vm_register(ARG1, Bytecode::Register::accumulator());
  1197. native_call((void*)cxx_get_object_property_iterator);
  1198. store_vm_register(Bytecode::Register::accumulator(), RET);
  1199. check_exception();
  1200. }
  1201. static Value cxx_get_private_by_id(VM& vm, Value base_value, DeprecatedFlyString& name)
  1202. {
  1203. auto private_reference = make_private_reference(vm, base_value, name);
  1204. return TRY_OR_SET_EXCEPTION(private_reference.get_value(vm));
  1205. }
  1206. void Compiler::compile_get_private_by_id(Bytecode::Op::GetPrivateById const& op)
  1207. {
  1208. load_vm_register(ARG1, Bytecode::Register::accumulator());
  1209. m_assembler.mov(
  1210. Assembler::Operand::Register(ARG2),
  1211. Assembler::Operand::Imm(bit_cast<u64>(&m_bytecode_executable.get_identifier(op.property()))));
  1212. native_call((void*)cxx_get_private_by_id);
  1213. store_vm_register(Bytecode::Register::accumulator(), RET);
  1214. check_exception();
  1215. }
  1216. static Value cxx_resolve_super_base(VM& vm)
  1217. {
  1218. // 1. Let env be GetThisEnvironment().
  1219. auto& env = verify_cast<FunctionEnvironment>(*get_this_environment(vm));
  1220. // 2. Assert: env.HasSuperBinding() is true.
  1221. VERIFY(env.has_super_binding());
  1222. // 3. Let baseValue be ? env.GetSuperBase().
  1223. return TRY_OR_SET_EXCEPTION(env.get_super_base());
  1224. }
  1225. void Compiler::compile_resolve_super_base(Bytecode::Op::ResolveSuperBase const&)
  1226. {
  1227. native_call((void*)cxx_resolve_super_base);
  1228. store_vm_register(Bytecode::Register::accumulator(), RET);
  1229. check_exception();
  1230. }
  1231. static Value cxx_get_by_id_with_this(VM& vm, Bytecode::IdentifierTableIndex property, Value base_value, Value this_value, u32 cache_index)
  1232. {
  1233. return TRY_OR_SET_EXCEPTION(get_by_id(vm.bytecode_interpreter(), property, base_value, this_value, cache_index));
  1234. }
  1235. void Compiler::compile_get_by_id_with_this(Bytecode::Op::GetByIdWithThis const& op)
  1236. {
  1237. m_assembler.mov(
  1238. Assembler::Operand::Register(ARG1),
  1239. Assembler::Operand::Imm(op.property().value()));
  1240. load_vm_register(ARG2, Bytecode::Register::accumulator());
  1241. load_vm_register(ARG3, op.this_value());
  1242. m_assembler.mov(
  1243. Assembler::Operand::Register(ARG4),
  1244. Assembler::Operand::Imm(op.cache_index()));
  1245. native_call((void*)cxx_get_by_id_with_this);
  1246. store_vm_register(Bytecode::Register::accumulator(), RET);
  1247. check_exception();
  1248. }
  1249. static Value cxx_get_by_value_with_this(VM& vm, Value property_key_value, Value base, Value this_value)
  1250. {
  1251. auto object = TRY_OR_SET_EXCEPTION(base.to_object(vm));
  1252. auto property_key = TRY_OR_SET_EXCEPTION(property_key_value.to_property_key(vm));
  1253. return TRY_OR_SET_EXCEPTION(object->internal_get(property_key, this_value));
  1254. }
  1255. void Compiler::compile_get_by_value_with_this(Bytecode::Op::GetByValueWithThis const& op)
  1256. {
  1257. load_vm_register(ARG1, Bytecode::Register::accumulator());
  1258. load_vm_register(ARG2, op.base());
  1259. load_vm_register(ARG3, op.this_value());
  1260. native_call((void*)cxx_get_by_value_with_this);
  1261. store_vm_register(Bytecode::Register::accumulator(), RET);
  1262. check_exception();
  1263. }
  1264. static Value cxx_delete_by_id_with_this(VM& vm, Value base_value, DeprecatedFlyString const& identifier, Value this_value)
  1265. {
  1266. auto reference = Reference { base_value, identifier, this_value, vm.in_strict_mode() };
  1267. return Value(TRY_OR_SET_EXCEPTION(reference.delete_(vm)));
  1268. }
  1269. void Compiler::compile_delete_by_id_with_this(Bytecode::Op::DeleteByIdWithThis const& op)
  1270. {
  1271. load_vm_register(ARG1, Bytecode::Register::accumulator());
  1272. m_assembler.mov(
  1273. Assembler::Operand::Register(ARG2),
  1274. Assembler::Operand::Imm(bit_cast<u64>(&m_bytecode_executable.get_identifier(op.property()))));
  1275. load_vm_register(ARG3, op.this_value());
  1276. native_call((void*)cxx_delete_by_id_with_this);
  1277. store_vm_register(Bytecode::Register::accumulator(), RET);
  1278. }
  1279. static Value cxx_put_by_id_with_this(VM& vm, Value base, Value value, DeprecatedFlyString const& name, Value this_value, Bytecode::Op::PropertyKind kind)
  1280. {
  1281. TRY_OR_SET_EXCEPTION(Bytecode::put_by_property_key(vm, base, this_value, value, name, kind));
  1282. return {};
  1283. }
  1284. void Compiler::compile_put_by_id_with_this(Bytecode::Op::PutByIdWithThis const& op)
  1285. {
  1286. load_vm_register(ARG1, op.base());
  1287. load_vm_register(ARG2, Bytecode::Register::accumulator());
  1288. m_assembler.mov(
  1289. Assembler::Operand::Register(ARG3),
  1290. Assembler::Operand::Imm(bit_cast<u64>(&m_bytecode_executable.get_identifier(op.property()))));
  1291. load_vm_register(ARG4, op.this_value());
  1292. m_assembler.mov(
  1293. Assembler::Operand::Register(ARG5),
  1294. Assembler::Operand::Imm(to_underlying(op.kind())));
  1295. native_call((void*)cxx_put_by_id_with_this);
  1296. check_exception();
  1297. }
  1298. static Value cxx_put_private_by_id(VM& vm, Value base, Value value, DeprecatedFlyString const& name)
  1299. {
  1300. auto object = TRY_OR_SET_EXCEPTION(base.to_object(vm));
  1301. auto private_reference = make_private_reference(vm, object, name);
  1302. TRY_OR_SET_EXCEPTION(private_reference.put_value(vm, value));
  1303. return value;
  1304. }
  1305. void Compiler::compile_put_private_by_id(Bytecode::Op::PutPrivateById const& op)
  1306. {
  1307. load_vm_register(ARG1, op.base());
  1308. load_vm_register(ARG2, Bytecode::Register::accumulator());
  1309. m_assembler.mov(
  1310. Assembler::Operand::Register(ARG3),
  1311. Assembler::Operand::Imm(bit_cast<u64>(&m_bytecode_executable.get_identifier(op.property()))));
  1312. native_call((void*)cxx_put_private_by_id);
  1313. store_vm_register(Bytecode::Register::accumulator(), RET);
  1314. check_exception();
  1315. }
  1316. static Value cxx_import_call(VM& vm, Value specifier, Value options)
  1317. {
  1318. return TRY_OR_SET_EXCEPTION(perform_import_call(vm, specifier, options));
  1319. }
  1320. void Compiler::compile_import_call(Bytecode::Op::ImportCall const& op)
  1321. {
  1322. load_vm_register(ARG1, op.specifier());
  1323. load_vm_register(ARG2, op.options());
  1324. native_call((void*)cxx_import_call);
  1325. store_vm_register(Bytecode::Register::accumulator(), RET);
  1326. check_exception();
  1327. }
  1328. static Value cxx_get_import_meta(VM& vm)
  1329. {
  1330. return vm.get_import_meta();
  1331. }
  1332. void Compiler::compile_get_import_meta(Bytecode::Op::GetImportMeta const&)
  1333. {
  1334. native_call((void*)cxx_get_import_meta);
  1335. store_vm_register(Bytecode::Register::accumulator(), RET);
  1336. }
  1337. static Value cxx_delete_variable(VM& vm, DeprecatedFlyString const& identifier)
  1338. {
  1339. auto reference = TRY_OR_SET_EXCEPTION(vm.resolve_binding(identifier));
  1340. return Value(TRY_OR_SET_EXCEPTION(reference.delete_(vm)));
  1341. }
  1342. void Compiler::compile_delete_variable(Bytecode::Op::DeleteVariable const& op)
  1343. {
  1344. m_assembler.mov(
  1345. Assembler::Operand::Register(ARG1),
  1346. Assembler::Operand::Imm(bit_cast<u64>(&m_bytecode_executable.get_identifier(op.identifier().value()))));
  1347. native_call((void*)cxx_delete_variable);
  1348. store_vm_register(Bytecode::Register::accumulator(), RET);
  1349. check_exception();
  1350. }
  1351. static Value cxx_get_method(VM& vm, Value value, DeprecatedFlyString const& identifier)
  1352. {
  1353. auto method = TRY_OR_SET_EXCEPTION(value.get_method(vm, identifier));
  1354. return method ?: js_undefined();
  1355. }
  1356. void Compiler::compile_get_method(Bytecode::Op::GetMethod const& op)
  1357. {
  1358. load_vm_register(ARG1, Bytecode::Register::accumulator());
  1359. m_assembler.mov(
  1360. Assembler::Operand::Register(ARG2),
  1361. Assembler::Operand::Imm(bit_cast<u64>(&m_bytecode_executable.get_identifier(op.property()))));
  1362. native_call((void*)cxx_get_method);
  1363. store_vm_register(Bytecode::Register::accumulator(), RET);
  1364. check_exception();
  1365. }
  1366. void Compiler::jump_to_exit()
  1367. {
  1368. m_assembler.jump(m_exit_label);
  1369. }
  1370. void Compiler::native_call(void* function_address, Vector<Assembler::Operand> const& stack_arguments)
  1371. {
  1372. // Make sure we don't clobber the VM&.
  1373. m_assembler.push(Assembler::Operand::Register(ARG0));
  1374. // Align the stack pointer.
  1375. m_assembler.sub(Assembler::Operand::Register(STACK_POINTER), Assembler::Operand::Imm(8));
  1376. // NOTE: We don't preserve caller-saved registers when making a native call.
  1377. // This means that they may have changed after we return from the call.
  1378. m_assembler.native_call(function_address, stack_arguments);
  1379. // Restore the stack pointer.
  1380. m_assembler.add(Assembler::Operand::Register(STACK_POINTER), Assembler::Operand::Imm(8));
  1381. // Restore our VM&.
  1382. m_assembler.pop(Assembler::Operand::Register(ARG0));
  1383. }
  1384. OwnPtr<NativeExecutable> Compiler::compile(Bytecode::Executable& bytecode_executable)
  1385. {
  1386. if (!getenv("LIBJS_JIT"))
  1387. return nullptr;
  1388. Compiler compiler { bytecode_executable };
  1389. compiler.m_assembler.enter();
  1390. compiler.m_assembler.mov(
  1391. Assembler::Operand::Register(REGISTER_ARRAY_BASE),
  1392. Assembler::Operand::Register(ARG1));
  1393. compiler.m_assembler.mov(
  1394. Assembler::Operand::Register(LOCALS_ARRAY_BASE),
  1395. Assembler::Operand::Register(ARG2));
  1396. compiler.push_unwind_context(false, {}, {});
  1397. for (auto& block : bytecode_executable.basic_blocks) {
  1398. compiler.block_data_for(*block).start_offset = compiler.m_output.size();
  1399. auto it = Bytecode::InstructionStreamIterator(block->instruction_stream());
  1400. while (!it.at_end()) {
  1401. auto const& op = *it;
  1402. switch (op.type()) {
  1403. # define CASE_BYTECODE_OP(OpTitleCase, op_snake_case) \
  1404. case Bytecode::Instruction::Type::OpTitleCase: \
  1405. compiler.compile_##op_snake_case(static_cast<Bytecode::Op::OpTitleCase const&>(op)); \
  1406. break;
  1407. JS_ENUMERATE_IMPLEMENTED_JIT_OPS(CASE_BYTECODE_OP)
  1408. # undef CASE_BYTECODE_OP
  1409. default:
  1410. if constexpr (LOG_JIT_FAILURE) {
  1411. dbgln("\033[31;1mJIT compilation failed\033[0m: {}", bytecode_executable.name);
  1412. dbgln("Unsupported bytecode op: {}", op.to_deprecated_string(bytecode_executable));
  1413. }
  1414. return nullptr;
  1415. }
  1416. ++it;
  1417. }
  1418. if (!block->is_terminated())
  1419. compiler.jump_to_exit();
  1420. }
  1421. compiler.m_exit_label.link(compiler.m_assembler);
  1422. compiler.m_assembler.exit();
  1423. if (!compiler.m_exception_handler.jump_slot_offsets_in_instruction_stream.is_empty()) {
  1424. compiler.m_exception_handler.link(compiler.m_assembler);
  1425. compiler.handle_exception();
  1426. }
  1427. auto* executable_memory = mmap(nullptr, compiler.m_output.size(), PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
  1428. if (executable_memory == MAP_FAILED) {
  1429. dbgln("mmap: {}", strerror(errno));
  1430. return nullptr;
  1431. }
  1432. for (auto& block : bytecode_executable.basic_blocks) {
  1433. auto& block_data = compiler.block_data_for(*block);
  1434. block_data.label.link_to(compiler.m_assembler, block_data.start_offset);
  1435. // Patch up all the absolute references
  1436. for (auto& absolute_reference : block_data.absolute_references_to_here) {
  1437. auto offset = bit_cast<u64>(executable_memory) + block_data.start_offset;
  1438. compiler.m_output[absolute_reference + 0] = (offset >> 0) & 0xff;
  1439. compiler.m_output[absolute_reference + 1] = (offset >> 8) & 0xff;
  1440. compiler.m_output[absolute_reference + 2] = (offset >> 16) & 0xff;
  1441. compiler.m_output[absolute_reference + 3] = (offset >> 24) & 0xff;
  1442. compiler.m_output[absolute_reference + 4] = (offset >> 32) & 0xff;
  1443. compiler.m_output[absolute_reference + 5] = (offset >> 40) & 0xff;
  1444. compiler.m_output[absolute_reference + 6] = (offset >> 48) & 0xff;
  1445. compiler.m_output[absolute_reference + 7] = (offset >> 56) & 0xff;
  1446. }
  1447. }
  1448. if constexpr (DUMP_JIT_MACHINE_CODE_TO_STDOUT) {
  1449. (void)write(STDOUT_FILENO, compiler.m_output.data(), compiler.m_output.size());
  1450. }
  1451. memcpy(executable_memory, compiler.m_output.data(), compiler.m_output.size());
  1452. if (mprotect(executable_memory, compiler.m_output.size(), PROT_READ | PROT_EXEC) < 0) {
  1453. dbgln("mprotect: {}", strerror(errno));
  1454. return nullptr;
  1455. }
  1456. if constexpr (LOG_JIT_SUCCESS) {
  1457. dbgln("\033[32;1mJIT compilation succeeded!\033[0m {}", bytecode_executable.name);
  1458. }
  1459. auto executable = make<NativeExecutable>(executable_memory, compiler.m_output.size());
  1460. if constexpr (DUMP_JIT_DISASSEMBLY)
  1461. executable->dump_disassembly();
  1462. return executable;
  1463. }
  1464. }
  1465. #endif