Fix several style fixes for typed arrays and optimize filter a bit. (#1697)

JerryScript-DCO-1.0-Signed-off-by: Zoltan Herczeg zherczeg.u-szeged@partner.samsung.com

jerry-core/ecma/builtin-objects/typedarray/ecma-builtin-typedarray-prototype.c

@@ -548,15 +548,19 @@ ecma_builtin_typedarray_prototype_filter (ecma_value_t this_arg, /**< this argum
 
   ecma_object_t *obj_p = ecma_get_object_from_value (this_arg);
   uint32_t len = ecma_typedarray_get_length (obj_p);
+  lit_utf8_byte_t *buffer_p = ecma_typedarray_get_buffer (obj_p);
+  uint8_t shift = ecma_typedarray_get_element_size_shift (obj_p);
+  uint8_t element_size = (uint8_t) (1 << shift);
   ecma_object_t *func_object_p = ecma_get_object_from_value (cb_func_val);
   ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
-  uint32_t pass_num = 0;
 
-  JMEM_DEFINE_LOCAL_ARRAY (pass_value_list, len, ecma_value_t);
+  JMEM_DEFINE_LOCAL_ARRAY (pass_value_list_p, len * element_size, lit_utf8_byte_t);
+
+  lit_utf8_byte_t *pass_value_p = pass_value_list_p;
 
   for (uint32_t index = 0; index < len && ecma_is_value_empty (ret_value); index++)
   {
-    ecma_value_t current_index =  ecma_make_uint32_value (index);
+    ecma_value_t current_index = ecma_make_uint32_value (index);
     ecma_value_t get_value = ecma_op_typedarray_get_index_prop (obj_p, index);
 
     JERRY_ASSERT (ecma_is_value_number (get_value));
@@ -567,10 +571,12 @@ ecma_builtin_typedarray_prototype_filter (ecma_value_t this_arg, /**< this argum
 
     if (ecma_op_to_boolean (call_value))
     {
-      *(pass_value_list + pass_num) = ecma_fast_copy_value (get_value);
-      pass_num++;
+      memcpy (pass_value_p, buffer_p, element_size);
+      pass_value_p += element_size;
     }
 
+    buffer_p += element_size;
+
     ECMA_FINALIZE (call_value);
 
     ecma_fast_free_value (current_index);
@@ -579,46 +585,24 @@ ecma_builtin_typedarray_prototype_filter (ecma_value_t this_arg, /**< this argum
 
   if (ecma_is_value_empty (ret_value))
   {
-    ecma_value_t new_typedarray = ecma_op_create_typedarray_with_type_and_length (obj_p, pass_num);
+    uint32_t pass_num = (uint32_t) ((pass_value_p - pass_value_list_p) >> shift);
 
-    if (ECMA_IS_VALUE_ERROR (new_typedarray))
+    ret_value = ecma_op_create_typedarray_with_type_and_length (obj_p, pass_num);
+
+
+    if (!ECMA_IS_VALUE_ERROR (ret_value))
     {
-      ret_value = new_typedarray;
-    }
-    else
-    {
-      ecma_object_t *new_obj_p = ecma_get_object_from_value (new_typedarray);
+      obj_p = ecma_get_object_from_value (ret_value);
 
-      for (uint32_t index = 0; index < pass_num && ecma_is_value_empty (ret_value); index++)
-      {
-        bool set_status = ecma_op_typedarray_set_index_prop (new_obj_p, index, *(pass_value_list + index));
+      JERRY_ASSERT (ecma_typedarray_get_offset (obj_p) == 0);
 
-        if (!set_status)
-        {
-          ret_value = ecma_raise_type_error (ECMA_ERR_MSG ("error in typedarray set"));
-        }
-      }
-
-      if (ecma_is_value_empty (ret_value))
-      {
-        ret_value = new_typedarray;
-      }
-      else
-      {
-        ecma_free_value (new_typedarray);
-      }
+      memcpy (ecma_typedarray_get_buffer (obj_p),
+              pass_value_list_p,
+              (size_t) (pass_value_p - pass_value_list_p));
     }
   }
 
-  uint32_t index = 0;
-
-  while (index < pass_num)
-  {
-    ecma_fast_free_value (*(pass_value_list + index));
-    index++;
-  }
-
-  JMEM_FINALIZE_LOCAL_ARRAY (pass_value_list);
+  JMEM_FINALIZE_LOCAL_ARRAY (pass_value_list_p);
 
   return ret_value;
 } /* ecma_builtin_typedarray_prototype_filter */
@@ -642,9 +626,7 @@ ecma_builtin_typedarray_prototype_reverse (ecma_value_t this_arg) /**< this argu
 
   ecma_object_t *obj_p = ecma_get_object_from_value (this_arg);
   uint32_t len = ecma_typedarray_get_length (obj_p);
-  ecma_object_t *arraybuffer_p = ecma_typedarray_get_arraybuffer (obj_p);
-  lit_utf8_byte_t *buffer = (ecma_arraybuffer_get_buffer (arraybuffer_p)
-                             + ecma_typedarray_get_offset (obj_p));
+  lit_utf8_byte_t *buffer_p = ecma_typedarray_get_buffer (obj_p);
   uint8_t shift = ecma_typedarray_get_element_size_shift (obj_p);
   uint8_t element_size = (uint8_t) (1 << shift);
   uint32_t middle = (len / 2) << shift;
@@ -653,8 +635,8 @@ ecma_builtin_typedarray_prototype_reverse (ecma_value_t this_arg) /**< this argu
   for (uint32_t lower = 0; lower < middle; lower += element_size)
   {
     uint32_t upper = buffer_last - lower;
-    lit_utf8_byte_t *lower_p = buffer + lower;
-    lit_utf8_byte_t *upper_p = buffer + upper;
+    lit_utf8_byte_t *lower_p = buffer_p + lower;
+    lit_utf8_byte_t *upper_p = buffer_p + upper;
 
     lit_utf8_byte_t tmp[8];
     memcpy (&tmp[0], lower_p, element_size);

jerry-core/ecma/operations/ecma-arraybuffer-object.c

@@ -112,24 +112,23 @@ ecma_arraybuffer_new_object (ecma_length_t length) /**< length of the arraybuffe
  *
  * See also: ES2015 24.1.1.4
  *
- * @return ecma_object_t *
+ * @return cloned array buffer
  */
 ecma_object_t *
-ecma_arraybuffer_new_object_by_clone_arraybuffer (ecma_object_t *src_p, /**< the src arraybuffer  */
-                                                  ecma_length_t offset) /**< the offset */
+ecma_arraybuffer_clone_arraybuffer (ecma_object_t *array_buf_p, /**< the cloned array buffer  */
+                                    ecma_length_t offset) /**< start offset */
 {
-  ecma_length_t length = ecma_arraybuffer_get_length (src_p);
 
-  JERRY_ASSERT (offset <= length);
+  JERRY_ASSERT (offset <= ecma_arraybuffer_get_length (array_buf_p));
 
-  ecma_length_t clone_length = length - offset;
-  ecma_object_t *dst_p = ecma_arraybuffer_new_object (clone_length);
-  lit_utf8_byte_t *src_buf = ecma_arraybuffer_get_buffer (src_p);
-  lit_utf8_byte_t *dst_buf = ecma_arraybuffer_get_buffer (dst_p);
-  memcpy (dst_buf, src_buf + offset, clone_length);
+  ecma_length_t length = ecma_arraybuffer_get_length (array_buf_p) - offset;
+  ecma_object_t *new_array_buf_p = ecma_arraybuffer_new_object (length);
+  lit_utf8_byte_t *src_buf_p = ecma_arraybuffer_get_buffer (array_buf_p);
+  lit_utf8_byte_t *dst_buf_p = ecma_arraybuffer_get_buffer (new_array_buf_p);
+  memcpy (dst_buf_p, src_buf_p + offset, length);
 
-  return dst_p;
-} /* ecma_arraybuffer_new_object_by_clone_arraybuffer */
+  return new_array_buf_p;
+} /* ecma_arraybuffer_clone_arraybuffer */
 
 /**
  * Helper function: check if the target is ArrayBuffer
@@ -137,8 +136,8 @@ ecma_arraybuffer_new_object_by_clone_arraybuffer (ecma_object_t *src_p, /**< the
  *
  * See also: ES2015 24.1.1.4
  *
- * @return bool True if it is ArrayBuffer
- *              Flase if it is not Object or it is not ArrayBuffer
+ * @return true - if value is an ArrayBuffer object
+ *         false - otherwise
  */
 bool
 ecma_is_arraybuffer (ecma_value_t target) /**< the target value */
@@ -173,7 +172,7 @@ ecma_arraybuffer_get_length (ecma_object_t *object_p) /**< pointer to the ArrayB
  *
  * @return pointer to the data buffer
  */
-lit_utf8_byte_t * __attr_pure___
+inline lit_utf8_byte_t * __attr_pure___ __attr_always_inline___
 ecma_arraybuffer_get_buffer (ecma_object_t *object_p) /**< pointer to the ArrayBuffer object */
 {
   JERRY_ASSERT (ecma_object_class_is (object_p, LIT_MAGIC_STRING_ARRAY_BUFFER_UL));

jerry-core/ecma/operations/ecma-arraybuffer-object.h

@@ -35,7 +35,7 @@ ecma_op_create_arraybuffer_object (const ecma_value_t *, ecma_length_t);
 ecma_object_t *
 ecma_arraybuffer_new_object (ecma_length_t lengh);
 ecma_object_t *
-ecma_arraybuffer_new_object_by_clone_arraybuffer (ecma_object_t *src_p, ecma_length_t offset);
+ecma_arraybuffer_clone_arraybuffer (ecma_object_t *src_p, ecma_length_t offset);
 lit_utf8_byte_t *
 ecma_arraybuffer_get_buffer (ecma_object_t *obj_p) __attr_pure___;
 ecma_length_t

jerry-core/ecma/operations/ecma-typedarray-object.c

@@ -314,8 +314,8 @@ ecma_typedarray_create_object_with_typedarray (ecma_object_t *typedarray_p, /**<
 
   if (src_class_id == class_id)
   {
-    arraybuffer_p = ecma_arraybuffer_new_object_by_clone_arraybuffer (src_arraybuffer_p,
-                                                                      byte_offset);
+    arraybuffer_p = ecma_arraybuffer_clone_arraybuffer (src_arraybuffer_p,
+                                                        byte_offset);
   }
   else
   {
@@ -487,7 +487,7 @@ ecma_op_typedarray_from (ecma_value_t items_val, /**< the source array-like obje
  *
  * @return the pointer to the internal arraybuffer
  */
-ecma_object_t *
+inline ecma_object_t * __attr_always_inline___
 ecma_typedarray_get_arraybuffer (ecma_object_t *typedarray_p) /**< the pointer to the typedarray object */
 {
   JERRY_ASSERT (ecma_is_typedarray (ecma_make_object_value (typedarray_p)));
@@ -561,6 +561,18 @@ ecma_typedarray_get_offset (ecma_object_t *typedarray_p) /**< the pointer to the
   return info_p->byte_offset;
 } /* ecma_typedarray_get_offset */
 
+/**
+ * Utility function: return the pointer of the data buffer referenced by the typed array
+ *
+ * @return pointer to the data buffer
+ */
+lit_utf8_byte_t *
+ecma_typedarray_get_buffer (ecma_object_t *typedarray_p) /**< the pointer to the typed array object */
+{
+  ecma_object_t *arraybuffer_p = ecma_typedarray_get_arraybuffer (typedarray_p);
+
+  return ecma_arraybuffer_get_buffer (arraybuffer_p) + ecma_typedarray_get_offset (typedarray_p);
+} /* ecma_typedarray_get_buffer */
 
 /**
  * Create a new typedarray object.
@@ -718,18 +730,18 @@ ecma_op_create_typedarray (const ecma_value_t *arguments_list_p, /**< the arg li
 /**
  * Check if the value is typedarray
  *
- * @return True: it is a typedarray object
- *         False: it is not object or it is not a typedarray
+ * @return true - if value is a TypedArray object
+ *         false - otherwise
  */
 bool
-ecma_is_typedarray (ecma_value_t target) /**< the target need to be checked */
+ecma_is_typedarray (ecma_value_t value) /**< the target need to be checked */
 {
-  if (!ecma_is_value_object (target))
+  if (!ecma_is_value_object (value))
   {
     return false;
   }
 
-  ecma_object_t *obj_p = ecma_get_object_from_value (target);
+  ecma_object_t *obj_p = ecma_get_object_from_value (value);
 
   if (ecma_get_object_type (obj_p) == ECMA_OBJECT_TYPE_PSEUDO_ARRAY)
   {
@@ -772,7 +784,7 @@ ecma_op_typedarray_list_lazy_property_names (ecma_object_t *obj_p, /**< a TypedA
  * See also: ES2015 9.4.5.8
  *
  * @return ecma value
- *         if failed, return undefined value
+ *         returns undefined if index is greater or equal than length
  */
 ecma_value_t
 ecma_op_typedarray_get_index_prop (ecma_object_t *obj_p, /**< a TypedArray object */

jerry-core/ecma/operations/ecma-typedarray-object.h

@@ -34,6 +34,7 @@ ecma_value_t ecma_op_typedarray_from (ecma_value_t items_val,
                                       lit_magic_string_id_t class_id);
 ecma_length_t ecma_typedarray_get_length (ecma_object_t *typedarray_p);
 ecma_length_t ecma_typedarray_get_offset (ecma_object_t *typedarray_p);
+lit_utf8_byte_t *ecma_typedarray_get_buffer (ecma_object_t *typedarray_p);
 uint8_t ecma_typedarray_get_element_size_shift (ecma_object_t *typedarray_p);
 ecma_object_t *ecma_typedarray_get_arraybuffer (ecma_object_t *typedarray_p);
 ecma_value_t ecma_op_create_typedarray (const ecma_value_t *arguments_list_p,