Minor fixes

JerryScript-DCO-1.0-Signed-off-by: László Langó llango.u-szeged@partner.samsung.com

Author: LaszloLango

jerry-core/ecma/base/ecma-gc.c

@@ -32,6 +32,7 @@
 #include "jrt.h"
 #include "jrt-libc-includes.h"
 #include "jrt-bit-fields.h"
+#include "re-compiler.h"
 #include "vm-defines.h"
 #include "vm-stack.h"
 
@@ -549,6 +550,11 @@ ecma_gc_run (void)
   ecma_gc_objects_lists[ECMA_GC_COLOR_BLACK] = NULL;
 
   ecma_gc_visited_flip_flag = !ecma_gc_visited_flip_flag;
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_REGEXP_BUILTIN
+  /* Free RegExp bytecodes stored in cache */
+  re_cache_gc_run ();
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_REGEXP_BUILTIN */
 } /* ecma_gc_run */
 
 /**

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

@@ -234,7 +234,7 @@ re_initialize_props (ecma_object_t *re_obj_p, /**< RegExp obejct */
  *         Returned value must be freed with ecma_free_value
  */
 ecma_value_t
-ecma_op_create_regexp_object_from_bytecode (re_compiled_code_t *bytecode_p) /**< input pattern */
+ecma_op_create_regexp_object_from_bytecode (re_compiled_code_t *bytecode_p) /**< RegExp bytecode */
 {
   JERRY_ASSERT (bytecode_p != NULL);
 

jerry-core/jerry.c

@@ -1653,9 +1653,9 @@ jerry_cleanup (void)
 
   bool is_show_mem_stats = ((jerry_flags & JERRY_FLAG_MEM_STATS) != 0);
 
+  vm_finalize ();
   ecma_finalize ();
   lit_finalize ();
-  vm_finalize ();
   mem_finalize (is_show_mem_stats);
 } /* jerry_cleanup */
 

jerry-core/parser/js/js-lexer.c

@@ -1812,7 +1812,6 @@ lexer_construct_regexp_object (parser_context_t *context_p, /**< context */
   ecma_value_t completion_value;
 
   ecma_string_t *pattern_str_p = ecma_new_ecma_string_from_utf8 (regex_start_p, length);
-  // FIXME: check return value of 're_compile_bytecode' and throw an error
   completion_value = re_compile_bytecode (&re_bytecode_p,
                                           pattern_str_p,
                                           current_flags);

jerry-core/parser/regexp/re-bytecode.h

@@ -34,7 +34,12 @@
 /**
   * Size of the RegExp bytecode cache
   */
-#define RE_CHACHE_SIZE 10u
+#define RE_CACHE_SIZE 8u
+
+/**
+  * RegExp flags mask (first 10 bits are for reference count and the rest for the actual RegExp flags)
+  */
+#define RE_FLAGS_MASK 0x3F
 
 /**
  * RegExp opcodes

jerry-core/parser/regexp/re-compiler.c

@@ -444,31 +444,34 @@ re_parse_alternative (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context
   return ret_value;
 } /* re_parse_alternative */
 
-static const re_compiled_code_t *re_cache[RE_CHACHE_SIZE];
+static const re_compiled_code_t *re_cache[RE_CACHE_SIZE];
 
 /**
  * Search for the given pattern in the RegExp cache
  *
  * @return compiled bytecode - if found
- *         NULL - otherwise
+ *         NULL              - otherwise
  */
-static re_compiled_code_t *
+re_compiled_code_t *
 re_find_bytecode_in_cache (ecma_string_t *pattern_str_p, /**< pattern string */
+                           uint16_t flags, /**< flags */
                            uint32_t *idx) /**< [out] index */
 {
-  uint32_t free_idx = RE_CHACHE_SIZE;
+  uint32_t free_idx = RE_CACHE_SIZE;
 
-  for (*idx = 0u; *idx < RE_CHACHE_SIZE && re_cache[*idx] != NULL; (*idx)++)
+  for (*idx = 0u; *idx < RE_CACHE_SIZE; (*idx)++)
   {
     re_compiled_code_t *cached_bytecode_p = re_cache[*idx];
 
-    if ((cached_bytecode_p->flags >> ECMA_BYTECODE_REF_SHIFT) > 0)
+    if (cached_bytecode_p != NULL)
     {
       ecma_string_t *cached_pattern_str_p;
       cached_pattern_str_p = ECMA_GET_NON_NULL_POINTER (ecma_string_t, cached_bytecode_p->pattern_cp);
 
-      if (ecma_compare_ecma_strings (cached_pattern_str_p, pattern_str_p))
+      if ((cached_bytecode_p->flags & RE_FLAGS_MASK) == flags
+          && ecma_compare_ecma_strings (cached_pattern_str_p, pattern_str_p))
       {
+        JERRY_DDLOG ("RegExp is found in cache\n");
         return re_cache[*idx];
       }
     }
@@ -479,11 +482,31 @@ re_find_bytecode_in_cache (ecma_string_t *pattern_str_p, /**< pattern string */
     }
   }
 
+  JERRY_DDLOG ("RegExp is NOT found in cache\n");
   *idx = free_idx;
-
   return NULL;
 } /* re_find_bytecode_in_cache */
 
+/**
+ * Run gerbage collection in RegExp cache
+ */
+void
+re_cache_gc_run ()
+{
+  for (uint32_t i = 0u; i < RE_CACHE_SIZE; i++)
+  {
+    re_compiled_code_t *cached_bytecode_p = re_cache[i];
+
+    if (cached_bytecode_p != NULL
+        && (cached_bytecode_p->flags >> ECMA_BYTECODE_REF_SHIFT) == 1)
+    { /* Only the cache has reference for the bytecode */
+
+      ecma_bytecode_deref (cached_bytecode_p);
+      re_cache[i] = NULL;
+    }
+  }
+} /* re_cache_gc_run */
+
 /**
  * Compilation of RegExp bytecode
  *
@@ -511,7 +534,7 @@ re_compile_bytecode (re_compiled_code_t **out_bytecode_p, /**< [out] pointer to
   re_ctx.bytecode_ctx_p = &bc_ctx;
 
   uint32_t cache_idx;
-  *out_bytecode_p = re_find_bytecode_in_cache (pattern_str_p, &cache_idx);
+  *out_bytecode_p = re_find_bytecode_in_cache (pattern_str_p, flags, &cache_idx);
 
   if (*out_bytecode_p != NULL)
   {
@@ -578,8 +601,9 @@ re_compile_bytecode (re_compiled_code_t **out_bytecode_p, /**< [out] pointer to
       JERRY_ASSERT (bc_ctx.block_start_p != NULL);
       *out_bytecode_p = (re_compiled_code_t *) bc_ctx.block_start_p;
 
-      if (cache_idx < RE_CHACHE_SIZE)
+      if (cache_idx < RE_CACHE_SIZE)
       {
+        ecma_bytecode_ref (*out_bytecode_p);
         re_cache[cache_idx] = *out_bytecode_p;
       }
       else

jerry-core/parser/regexp/re-compiler.h

@@ -50,6 +50,11 @@ typedef struct
 ecma_value_t
 re_compile_bytecode (re_compiled_code_t **, ecma_string_t *, uint16_t);
 
+re_compiled_code_t *
+re_find_bytecode_in_cache (ecma_string_t *pattern_str_p, uint16_t flags, uint32_t *idx);
+
+void re_cache_gc_run ();
+
 /**
  * @}
  * @}