Generator.cpp 5.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178
  1. /*
  2. * Copyright (c) 2021, Andreas Kling <kling@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <LibJS/AST.h>
  7. #include <LibJS/Bytecode/BasicBlock.h>
  8. #include <LibJS/Bytecode/Generator.h>
  9. #include <LibJS/Bytecode/Instruction.h>
  10. #include <LibJS/Bytecode/Op.h>
  11. #include <LibJS/Bytecode/Register.h>
  12. namespace JS::Bytecode {
  13. Generator::Generator()
  14. : m_string_table(make<StringTable>())
  15. , m_identifier_table(make<IdentifierTable>())
  16. {
  17. }
  18. Generator::~Generator()
  19. {
  20. }
  21. CodeGenerationErrorOr<NonnullOwnPtr<Executable>> Generator::generate(ASTNode const& node, FunctionKind enclosing_function_kind)
  22. {
  23. Generator generator;
  24. generator.switch_to_basic_block(generator.make_block());
  25. generator.m_enclosing_function_kind = enclosing_function_kind;
  26. if (generator.is_in_generator_or_async_function()) {
  27. // Immediately yield with no value.
  28. auto& start_block = generator.make_block();
  29. generator.emit<Bytecode::Op::Yield>(Label { start_block });
  30. generator.switch_to_basic_block(start_block);
  31. }
  32. TRY(node.generate_bytecode(generator));
  33. if (generator.is_in_generator_or_async_function()) {
  34. // Terminate all unterminated blocks with yield return
  35. for (auto& block : generator.m_root_basic_blocks) {
  36. if (block.is_terminated())
  37. continue;
  38. generator.switch_to_basic_block(block);
  39. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  40. generator.emit<Bytecode::Op::Yield>(nullptr);
  41. }
  42. }
  43. return adopt_own(*new Executable {
  44. .name = {},
  45. .basic_blocks = move(generator.m_root_basic_blocks),
  46. .string_table = move(generator.m_string_table),
  47. .identifier_table = move(generator.m_identifier_table),
  48. .number_of_registers = generator.m_next_register });
  49. }
  50. void Generator::grow(size_t additional_size)
  51. {
  52. VERIFY(m_current_basic_block);
  53. m_current_basic_block->grow(additional_size);
  54. }
  55. void* Generator::next_slot()
  56. {
  57. VERIFY(m_current_basic_block);
  58. return m_current_basic_block->next_slot();
  59. }
  60. Register Generator::allocate_register()
  61. {
  62. VERIFY(m_next_register != NumericLimits<u32>::max());
  63. return Register { m_next_register++ };
  64. }
  65. Label Generator::nearest_continuable_scope() const
  66. {
  67. return m_continuable_scopes.last();
  68. }
  69. void Generator::begin_continuable_scope(Label continue_target)
  70. {
  71. m_continuable_scopes.append(continue_target);
  72. }
  73. void Generator::end_continuable_scope()
  74. {
  75. m_continuable_scopes.take_last();
  76. }
  77. Label Generator::nearest_breakable_scope() const
  78. {
  79. return m_breakable_scopes.last();
  80. }
  81. void Generator::begin_breakable_scope(Label breakable_target)
  82. {
  83. m_breakable_scopes.append(breakable_target);
  84. }
  85. void Generator::end_breakable_scope()
  86. {
  87. m_breakable_scopes.take_last();
  88. }
  89. CodeGenerationErrorOr<void> Generator::emit_load_from_reference(JS::ASTNode const& node)
  90. {
  91. if (is<Identifier>(node)) {
  92. auto& identifier = static_cast<Identifier const&>(node);
  93. emit<Bytecode::Op::GetVariable>(intern_identifier(identifier.string()));
  94. return {};
  95. }
  96. if (is<MemberExpression>(node)) {
  97. auto& expression = static_cast<MemberExpression const&>(node);
  98. TRY(expression.object().generate_bytecode(*this));
  99. auto object_reg = allocate_register();
  100. emit<Bytecode::Op::Store>(object_reg);
  101. if (expression.is_computed()) {
  102. TRY(expression.property().generate_bytecode(*this));
  103. emit<Bytecode::Op::GetByValue>(object_reg);
  104. } else if (expression.property().is_identifier()) {
  105. auto identifier_table_ref = intern_identifier(verify_cast<Identifier>(expression.property()).string());
  106. emit<Bytecode::Op::GetById>(identifier_table_ref);
  107. } else {
  108. return CodeGenerationError {
  109. &expression,
  110. "Unimplemented non-computed member expression"sv
  111. };
  112. }
  113. return {};
  114. }
  115. VERIFY_NOT_REACHED();
  116. }
  117. CodeGenerationErrorOr<void> Generator::emit_store_to_reference(JS::ASTNode const& node)
  118. {
  119. if (is<Identifier>(node)) {
  120. auto& identifier = static_cast<Identifier const&>(node);
  121. emit<Bytecode::Op::SetVariable>(intern_identifier(identifier.string()));
  122. return {};
  123. }
  124. if (is<MemberExpression>(node)) {
  125. // NOTE: The value is in the accumulator, so we have to store that away first.
  126. auto value_reg = allocate_register();
  127. emit<Bytecode::Op::Store>(value_reg);
  128. auto& expression = static_cast<MemberExpression const&>(node);
  129. TRY(expression.object().generate_bytecode(*this));
  130. auto object_reg = allocate_register();
  131. emit<Bytecode::Op::Store>(object_reg);
  132. if (expression.is_computed()) {
  133. TRY(expression.property().generate_bytecode(*this));
  134. auto property_reg = allocate_register();
  135. emit<Bytecode::Op::Store>(property_reg);
  136. emit<Bytecode::Op::Load>(value_reg);
  137. emit<Bytecode::Op::PutByValue>(object_reg, property_reg);
  138. } else if (expression.property().is_identifier()) {
  139. emit<Bytecode::Op::Load>(value_reg);
  140. auto identifier_table_ref = intern_identifier(verify_cast<Identifier>(expression.property()).string());
  141. emit<Bytecode::Op::PutById>(object_reg, identifier_table_ref);
  142. } else {
  143. return CodeGenerationError {
  144. &expression,
  145. "Unimplemented non-computed member expression"sv
  146. };
  147. }
  148. return {};
  149. }
  150. VERIFY_NOT_REACHED();
  151. }
  152. String CodeGenerationError::to_string()
  153. {
  154. return String::formatted("CodeGenerationError in {}: {}", failing_node ? failing_node->class_name() : "<unknown node>", reason_literal);
  155. }
  156. }