Registering temporary variables arrays in ecma-stack frames, starting mark traverse from them during GC.

src/libcoreint/interpreter.c

@@ -454,17 +454,10 @@ run_int_from_pos (opcode_counter_t start_pos,
   const idx_t max_reg_num = curr->data.reg_var_decl.max;
   JERRY_ASSERT (max_reg_num >= min_reg_num);
 
-  const uint32_t regs_num = (uint32_t) (max_reg_num - min_reg_num + 1);
+  const int32_t regs_num = max_reg_num - min_reg_num + 1;
 
   MEM_DEFINE_LOCAL_ARRAY (regs, regs_num, ecma_value_t);
 
-  /* memseting with zero initializes each 'register' to empty value */
-  __memset (regs, 0, regs_num * sizeof (ecma_value_t));
-  JERRY_ASSERT (ecma_is_value_empty (regs[0]));
-
-  ecma_stack_frame_t frame;
-  ecma_stack_add_frame (&frame);
-
   int_data_t int_data;
   int_data.pos = (opcode_counter_t) (start_pos + 1);
   int_data.this_binding = this_binding_value;
@@ -473,9 +466,8 @@ run_int_from_pos (opcode_counter_t start_pos,
   int_data.is_eval_code = is_eval_code;
   int_data.min_reg_num = min_reg_num;
   int_data.max_reg_num = max_reg_num;
-  int_data.regs_p = regs;
   int_data.tmp_num_p = ecma_alloc_number ();
-  int_data.stack_frame_p = &frame;
+  ecma_stack_add_frame (&int_data.stack_frame, regs, regs_num);
 
 #ifdef MEM_STATS
   interp_mem_stats_context_enter (&int_data, start_pos);
@@ -488,17 +480,10 @@ run_int_from_pos (opcode_counter_t start_pos,
                 || ecma_is_completion_value_return (completion)
                 || ecma_is_completion_value_exit (completion));
 
-  ecma_stack_free_frame (&frame);
+  ecma_stack_free_frame (&int_data.stack_frame);
 
   ecma_dealloc_number (int_data.tmp_num_p);
 
-  for (uint32_t reg_index = 0;
-       reg_index < regs_num;
-       reg_index++)
-  {
-    ecma_free_value (regs[ reg_index ], true);
-  }
-
 #ifdef MEM_STATS
   interp_mem_stats_context_exit (&int_data, start_pos);
 #endif /* MEM_STATS */

src/libcoreint/opcodes-helpers-variables.c

@@ -81,7 +81,8 @@ get_variable_value (int_data_t *int_data, /**< interpreter context */
 
   if (is_reg_variable (int_data, var_idx))
   {
-    ecma_value_t reg_value = int_data->regs_p[ var_idx - int_data->min_reg_num ];
+    ecma_value_t reg_value = ecma_stack_frame_get_reg_value (&int_data->stack_frame,
+                                                             var_idx - int_data->min_reg_num);
 
     JERRY_ASSERT (!ecma_is_value_empty (reg_value));
 
@@ -134,7 +135,8 @@ set_variable_value (int_data_t *int_data, /**< interpreter context */
   {
     ret_value = ecma_make_empty_completion_value ();
 
-    ecma_value_t reg_value = int_data->regs_p[ var_idx - int_data->min_reg_num ];
+    ecma_value_t reg_value = ecma_stack_frame_get_reg_value (&int_data->stack_frame,
+                                                             var_idx - int_data->min_reg_num);
 
     if (ecma_is_value_number (reg_value)
         && ecma_is_value_number (value))
@@ -145,10 +147,12 @@ set_variable_value (int_data_t *int_data, /**< interpreter context */
     {
       if (!ecma_is_value_empty (reg_value))
       {
-        ecma_free_value (reg_value, true);
+        ecma_free_value (reg_value, false);
       }
 
-      int_data->regs_p[ var_idx - int_data->min_reg_num ] = ecma_copy_value (value, true);
+      ecma_stack_frame_set_reg_value (&int_data->stack_frame,
+                                      var_idx - int_data->min_reg_num,
+                                      ecma_copy_value (value, false));
     }
   }
   else

src/libcoreint/opcodes.h

@@ -82,9 +82,8 @@ typedef struct
   bool is_eval_code; /**< is current code executed with eval */
   idx_t min_reg_num; /**< minimum idx used for register identification */
   idx_t max_reg_num; /**< maximum idx used for register identification */
-  ecma_value_t *regs_p; /**< register variables */
   ecma_number_t* tmp_num_p; /**< an allocated number (to reduce temporary allocations) */
-  ecma_stack_frame_t *stack_frame_p; /**< ecma-stack frame associated with the context */
+  ecma_stack_frame_t stack_frame; /**< ecma-stack frame associated with the context */
 
 #ifdef MEM_STATS
   size_t context_peak_allocated_heap_bytes;

src/libecmaobjects/ecma-gc.c

@@ -1,4 +1,4 @@
-/* Copyright 2014 Samsung Electronics Co., Ltd.
+/* Copyright 2014-2015 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -29,6 +29,7 @@
 #include "ecma-gc.h"
 #include "ecma-helpers.h"
 #include "ecma-lcache.h"
+#include "ecma-stack.h"
 #include "globals.h"
 #include "jerry-libc.h"
 #include "jrt-bit-fields.h"
@@ -555,6 +556,28 @@ ecma_gc_run (ecma_gc_gen_t max_gen_to_collect) /**< maximum generation to run co
     }
   }
 
+  /* if some object is referenced from a register variable (i.e. it is root),
+   * start recursive marking traverse from the object */
+  for (ecma_stack_frame_t *frame_iter_p = ecma_stack_get_top_frame ();
+       frame_iter_p != NULL;
+       frame_iter_p = frame_iter_p->prev_frame_p)
+  {
+    for (int32_t reg_index = 0; reg_index < frame_iter_p->regs_number; reg_index++)
+    {
+      ecma_value_t reg_value = ecma_stack_frame_get_reg_value (frame_iter_p, reg_index);
+
+      if (ecma_is_value_object (reg_value))
+      {
+        ecma_object_t *obj_p = ecma_get_object_from_value (reg_value);
+
+        if (!ecma_gc_is_object_visited (obj_p))
+        {
+          ecma_gc_mark (obj_p, ECMA_GC_GEN_COUNT);
+        }
+      }
+    }
+  }
+
   /* if some object from generations that are not processed during current session may reference
    * younger generations, start recursive marking traverse from the object, but one the first level
    * consider only references to object of at most max_gen_to_collect generation */

src/libecmaobjects/ecma-stack.c

@@ -58,11 +58,24 @@ ecma_stack_finalize ()
   JERRY_ASSERT (ecma_stack_top_frame_p == NULL);
 } /* ecma_stack_finalize */
 
+/**
+ * Get ecma-stack's top frame
+ *
+ * @return pointer to the top frame descriptor
+ */
+ecma_stack_frame_t*
+ecma_stack_get_top_frame (void)
+{
+  return ecma_stack_top_frame_p;
+} /* ecma_stack_get_top_frame */
+
 /**
  * Add the frame to ecma-stack
  */
 void
-ecma_stack_add_frame (ecma_stack_frame_t *frame_p) /**< frame to initialize */
+ecma_stack_add_frame (ecma_stack_frame_t *frame_p, /**< frame to initialize */
+                      ecma_value_t *regs_p, /**< array of register variables' values */
+                      int32_t regs_num) /**< number of register variables */
 {
   frame_p->prev_frame_p = ecma_stack_top_frame_p;
   ecma_stack_top_frame_p = frame_p;
@@ -70,6 +83,13 @@ ecma_stack_add_frame (ecma_stack_frame_t *frame_p) /**< frame to initialize */
   frame_p->top_chunk_p = NULL;
   frame_p->dynamically_allocated_value_slots_p = frame_p->inlined_values;
   frame_p->current_slot_index = 0;
+  frame_p->regs_p = regs_p;
+  frame_p->regs_number = regs_num;
+
+  for (int32_t i = 0; i < regs_num; i++)
+  {
+    regs_p [i] = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
+  }
 } /* ecma_stack_add_frame */
 
 /**
@@ -90,8 +110,42 @@ ecma_stack_free_frame (ecma_stack_frame_t *frame_p) /**< frame to initialize */
   {
     ecma_stack_pop (frame_p);
   }
+
+  for (int32_t reg_index = 0;
+       reg_index < frame_p->regs_number;
+       reg_index++)
+  {
+    ecma_free_value (frame_p->regs_p [reg_index], false);
+  }
 } /* ecma_stack_free_frame */
 
+/**
+ * Get value of specified register variable
+ *
+ * @return ecma-value
+ */
+ecma_value_t
+ecma_stack_frame_get_reg_value (ecma_stack_frame_t *frame_p, /**< frame */
+                                int32_t reg_index) /**< index of register variable */
+{
+  JERRY_ASSERT (reg_index >= 0 && reg_index < frame_p->regs_number);
+
+  return frame_p->regs_p [reg_index];
+} /* ecma_stack_frame_get_reg_value */
+
+/**
+ * Set value of specified register variable
+ */
+void
+ecma_stack_frame_set_reg_value (ecma_stack_frame_t *frame_p, /**< frame */
+                                int32_t reg_index, /**< index of register variable */
+                                ecma_value_t value) /**< ecma-value */
+{
+  JERRY_ASSERT (reg_index >= 0 && reg_index < frame_p->regs_number);
+
+  frame_p->regs_p [reg_index] = value;
+} /* ecma_stack_frame_set_reg_value */
+
 /**
  * Calculate number of value slots in the top-most chunk of the frame
  *

src/libecmaobjects/ecma-stack.h

@@ -52,12 +52,21 @@ typedef struct ecma_stack_frame_t
   ecma_value_t inlined_values [ECMA_STACK_FRAME_INLINED_VALUES_NUMBER]; /**< place for values inlined in stack frame
                                                                          *   (instead of being dynamically allocated
                                                                          *   on the heap) */
+  ecma_value_t *regs_p; /**< register variables */
+  int32_t regs_number; /**< number of register variables */
 } ecma_stack_frame_t;
 
 extern void ecma_stack_init (void);
 extern void ecma_stack_finalize (void);
-extern void ecma_stack_add_frame (ecma_stack_frame_t *frame_p);
+extern ecma_stack_frame_t*
+ecma_stack_get_top_frame (void);
+extern void
+ecma_stack_add_frame (ecma_stack_frame_t *frame_p,
+                      ecma_value_t *regs_p,
+                      int32_t regs_num);
 extern void ecma_stack_free_frame (ecma_stack_frame_t *frame_p);
+extern ecma_value_t ecma_stack_frame_get_reg_value (ecma_stack_frame_t *frame_p, int32_t reg_index);
+extern void ecma_stack_frame_set_reg_value (ecma_stack_frame_t *frame_p, int32_t reg_index, ecma_value_t value);
 extern void ecma_stack_push_value (ecma_stack_frame_t *frame_p, ecma_value_t value);
 extern ecma_value_t ecma_stack_top_value (ecma_stack_frame_t *frame_p);
 extern void ecma_stack_pop (ecma_stack_frame_t *frame_p);

tests/jerry/gc.js

@@ -0,0 +1,24 @@
+// Copyright 2015 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+function f (o, i) {
+  if (--i > 0) {
+    f ({a:o, b:o}, i);
+  }
+}
+
+for (var i = 0; i < 100; i++)
+{
+  ({} + f ({}, 12));
+}