Shape.cpp 6.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191
  1. /*
  2. * Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
  3. * All rights reserved.
  4. *
  5. * Redistribution and use in source and binary forms, with or without
  6. * modification, are permitted provided that the following conditions are met:
  7. *
  8. * 1. Redistributions of source code must retain the above copyright notice, this
  9. * list of conditions and the following disclaimer.
  10. *
  11. * 2. Redistributions in binary form must reproduce the above copyright notice,
  12. * this list of conditions and the following disclaimer in the documentation
  13. * and/or other materials provided with the distribution.
  14. *
  15. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  16. * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  18. * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  19. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  21. * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  22. * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  23. * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  24. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25. */
  26. #include <LibJS/Interpreter.h>
  27. #include <LibJS/Runtime/Shape.h>
  28. namespace JS {
  29. Shape* Shape::create_unique_clone() const
  30. {
  31. auto* new_shape = heap().allocate<Shape>();
  32. new_shape->m_unique = true;
  33. new_shape->m_prototype = m_prototype;
  34. ensure_property_table();
  35. new_shape->ensure_property_table();
  36. (*new_shape->m_property_table) = *m_property_table;
  37. return new_shape;
  38. }
  39. Shape* Shape::create_put_transition(const FlyString& property_name, u8 attributes)
  40. {
  41. TransitionKey key { property_name, attributes };
  42. if (auto* existing_shape = m_forward_transitions.get(key).value_or(nullptr))
  43. return existing_shape;
  44. auto* new_shape = heap().allocate<Shape>(this, property_name, attributes, TransitionType::Put);
  45. m_forward_transitions.set(key, new_shape);
  46. return new_shape;
  47. }
  48. Shape* Shape::create_configure_transition(const FlyString& property_name, u8 attributes)
  49. {
  50. TransitionKey key { property_name, attributes };
  51. if (auto* existing_shape = m_forward_transitions.get(key).value_or(nullptr))
  52. return existing_shape;
  53. auto* new_shape = heap().allocate<Shape>(this, property_name, attributes, TransitionType::Configure);
  54. m_forward_transitions.set(key, new_shape);
  55. return new_shape;
  56. }
  57. Shape* Shape::create_prototype_transition(Object* new_prototype)
  58. {
  59. return heap().allocate<Shape>(this, new_prototype);
  60. }
  61. Shape::Shape()
  62. {
  63. }
  64. Shape::Shape(Shape* previous_shape, const FlyString& property_name, u8 attributes, TransitionType transition_type)
  65. : m_previous(previous_shape)
  66. , m_property_name(property_name)
  67. , m_attributes(attributes)
  68. , m_prototype(previous_shape->m_prototype)
  69. , m_transition_type(transition_type)
  70. {
  71. }
  72. Shape::Shape(Shape* previous_shape, Object* new_prototype)
  73. : m_previous(previous_shape)
  74. , m_prototype(new_prototype)
  75. , m_transition_type(TransitionType::Prototype)
  76. {
  77. }
  78. Shape::~Shape()
  79. {
  80. }
  81. void Shape::visit_children(Cell::Visitor& visitor)
  82. {
  83. Cell::visit_children(visitor);
  84. visitor.visit(m_prototype);
  85. visitor.visit(m_previous);
  86. for (auto& it : m_forward_transitions)
  87. visitor.visit(it.value);
  88. }
  89. Optional<PropertyMetadata> Shape::lookup(const FlyString& property_name) const
  90. {
  91. auto property = property_table().get(property_name);
  92. if (!property.has_value())
  93. return {};
  94. return property;
  95. }
  96. const HashMap<FlyString, PropertyMetadata>& Shape::property_table() const
  97. {
  98. ensure_property_table();
  99. return *m_property_table;
  100. }
  101. size_t Shape::property_count() const
  102. {
  103. return property_table().size();
  104. }
  105. Vector<Shape::Property> Shape::property_table_ordered() const
  106. {
  107. auto vec = Vector<Shape::Property>();
  108. vec.resize(property_table().size());
  109. for (auto& it : property_table()) {
  110. vec[it.value.offset] = { it.key, it.value };
  111. }
  112. return vec;
  113. }
  114. void Shape::ensure_property_table() const
  115. {
  116. if (m_property_table)
  117. return;
  118. m_property_table = make<HashMap<FlyString, PropertyMetadata>>();
  119. // FIXME: We need to make sure the GC doesn't collect the transition chain as we're building it.
  120. // Maybe some kind of RAII "prevent GC for a moment" helper thingy?
  121. Vector<const Shape*> transition_chain;
  122. for (auto* shape = this; shape->m_previous; shape = shape->m_previous) {
  123. transition_chain.append(shape);
  124. }
  125. u32 next_offset = 0;
  126. for (ssize_t i = transition_chain.size() - 1; i >= 0; --i) {
  127. auto* shape = transition_chain[i];
  128. if (shape->m_property_name.is_null()) {
  129. // Ignore prototype transitions as they don't affect the key map.
  130. continue;
  131. }
  132. if (shape->m_transition_type == TransitionType::Put) {
  133. m_property_table->set(shape->m_property_name, { next_offset++, shape->m_attributes });
  134. } else if (shape->m_transition_type == TransitionType::Configure) {
  135. auto it = m_property_table->find(shape->m_property_name);
  136. ASSERT(it != m_property_table->end());
  137. it->value.attributes = shape->m_attributes;
  138. }
  139. }
  140. }
  141. void Shape::add_property_to_unique_shape(const FlyString& property_name, u8 attributes)
  142. {
  143. ASSERT(is_unique());
  144. ASSERT(m_property_table);
  145. ASSERT(!m_property_table->contains(property_name));
  146. m_property_table->set(property_name, { m_property_table->size(), attributes });
  147. }
  148. void Shape::reconfigure_property_in_unique_shape(const FlyString& property_name, u8 attributes)
  149. {
  150. ASSERT(is_unique());
  151. ASSERT(m_property_table);
  152. ASSERT(m_property_table->contains(property_name));
  153. m_property_table->set(property_name, { m_property_table->size(), attributes });
  154. }
  155. void Shape::remove_property_from_unique_shape(const FlyString& property_name, size_t offset)
  156. {
  157. ASSERT(is_unique());
  158. ASSERT(m_property_table);
  159. m_property_table->remove(property_name);
  160. for (auto& it : *m_property_table) {
  161. ASSERT(it.value.offset != offset);
  162. if (it.value.offset > offset)
  163. --it.value.offset;
  164. }
  165. }
  166. }