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

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);