Introduce generic backtrace capturing (#4555)

Remove jerry_get_backtrace_from function

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

docs/02.API-REFERENCE.md

@@ -245,6 +245,15 @@ memory blocks but the performance may drop after the garbage collection.
 
 *New in version 2.0*.
 
+## jerry_backtrace_frame_types_t
+
+List of backtrace frame types returned by
+[jerry_backtrace_get_frame_type](#jerry_backtrace_get_frame_type).
+
+ - JERRY_BACKTRACE_FRAME_JS - indicates that the frame is created for a JavaScript function/method
+
+*New in version [[NEXT_RELEASE]]*.
+
 ## jerry_generate_snapshot_opts_t
 
 Flags for [jerry_generate_snapshot](#jerry_generate_snapshot) and
@@ -524,6 +533,50 @@ typedef struct
 
 - [jerry_define_own_property](#jerry_define_own_property)
 
+## jerry_backtrace_location_t
+
+**Summary**
+
+Source code location data retreived by
+[jerry_backtrace_get_location](#jerry_backtrace_get_location).
+
+**Prototype**
+
+```c
+typedef struct
+{
+  jerry_value_t resource_name; /**< resource name */
+  jerry_size_t line; /**< line index */
+  jerry_size_t column; /**< column index */
+} jerry_backtrace_location_t;
+```
+
+*New in version [[NEXT_RELEASE]]*.
+
+## jerry_backtrace_frame_t
+
+**Summary**
+
+Backtrace frame data passed to the [jerry_backtrace_callback_t](#jerry_backtrace_callback_t)
+handler. This is an internal data structure which fields can be accessed by helper functions
+such as [jerry_backtrace_get_location](#jerry_backtrace_get_location).
+
+**Prototype**
+
+```c
+/**
+ * Internal data structure for jerry_backtrace_frame_t definition.
+ */
+struct jerry_backtrace_frame_internal_t;
+
+/**
+ * Backtrace frame data passed to the jerry_backtrace_callback_t handler.
+ */
+typedef struct jerry_backtrace_frame_internal_t jerry_backtrace_frame_t;
+```
+
+*New in version [[NEXT_RELEASE]]*.
+
 ## jerry_heap_stats_t
 
 **Summary**
@@ -627,6 +680,32 @@ typedef void (*jerry_error_object_created_callback_t) (const jerry_value_t error
 
 - [jerry_set_error_object_created_callback](#jerry_set_error_object_created_callback)
 
+## jerry_backtrace_callback_t
+
+**Summary**
+
+Callback function which is called by [jerry_backtrace_capture](#jerry_backtrace_capture)
+for each stack frame.
+
+**Prototype**
+
+```c
+typedef bool (*jerry_backtrace_callback_t) (jerry_backtrace_frame_t *frame_p, void *user_p);
+```
+
+- `frame_p` - pointer to [jerry_backtrace_frame_t](#jerry_backtrace_frame_t) data.
+- `user_p` - pointer passed to [jerry_backtrace_capture](#jerry_backtrace_capture).
+- return value
+  - true, to continue capturing more frames
+  - false, to end the stack capturing
+
+*New in version [[NEXT_RELEASE]]*.
+
+**See also**
+
+- [jerry_backtrace_capture](#jerry_backtrace_capture)
+- [jerry_backtrace_frame_t](#jerry_backtrace_frame_t)
+
 ## jerry_object_native_info_t
 
 **Summary**
@@ -8931,90 +9010,7 @@ main (void)
 - [jerry_register_magic_strings](#jerry_register_magic_strings)
 
 
-# Miscellaneous functions
+# Backtrace functions
-
-## jerry_set_vm_exec_stop_callback
-
-**Summary**
-
-When JERRY_FEATURE_VM_EXEC_STOP is enabled a callback function can be
-specified by this function. This callback is periodically called when
-JerryScript executes an ECMAScript program.
-
-If the callback returns with undefined value the ECMAScript execution
-continues. Otherwise the result is thrown by the engine (if the error
-flag is not set for the returned value the engine automatically sets
-it). The callback function might be called again even if it threw
-an error. In this case the function must throw the same error again.
-
-To reduce the CPU overhead of constantly checking the termination
-condition the callback is called when a backward jump is executed
-or an exception is caught. Setting the `frequency` to a greater
-than `1` value reduces this overhead further. If its value is N
-only every Nth event (backward jump, etc.) trigger the next check.
-
-
-**Prototype**
-
-```c
-void
-jerry_set_vm_exec_stop_callback (jerry_vm_exec_stop_callback_t stop_cb,
-                                 void *user_p,
-                                 uint32_t frequency);
-```
-
-- `stop_cb` - periodically called callback (passing NULL disables this feature)
-- `user_p` - user pointer passed to the `stop_cb` function
-- `frequency` - frequency of calling the `stop_cb` function
-
-*New in version 2.0*.
-
-**Example**
-
-[doctest]: # (test="link")
-
-```c
-#include "jerryscript.h"
-
-static int countdown = 10;
-
-static jerry_value_t
-vm_exec_stop_callback (void *user_p)
-{
-  while (countdown > 0)
-  {
-    countdown--;
-    return jerry_create_undefined ();
-  }
-
-  // The error flag is added automatically.
-  return jerry_create_string ((const jerry_char_t *) "Abort script");
-}
-
-int
-main (void)
-{
-  jerry_init (JERRY_INIT_EMPTY);
-
-  jerry_set_vm_exec_stop_callback (vm_exec_stop_callback, &countdown, 16);
-
-  // Inifinte loop.
-  const jerry_char_t script[] = "while(true) {}";
-
-  jerry_value_t parsed_code = jerry_parse (NULL, 0, script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
-  jerry_release_value (jerry_run (parsed_code));
-  jerry_release_value (parsed_code);
-  jerry_cleanup ();
-}
-```
-
-**See also**
-
-- [jerry_init](#jerry_init)
-- [jerry_cleanup](#jerry_cleanup)
-- [jerry_parse](#jerry_parse)
-- [jerry_run](#jerry_run)
-- [jerry_vm_exec_stop_callback_t](#jerry_vm_exec_stop_callback_t)
 
 ## jerry_get_backtrace
 
@@ -9099,7 +9095,7 @@ main (void)
 
   jerry_value_t global = jerry_get_global_object ();
 
-  /* Register the "dump_backtrace" method. */
+  /* Register the "capture_backtrace" method. */
   {
     jerry_value_t func = jerry_create_external_function (backtrace_handler);
     jerry_value_t name = jerry_create_string ((const jerry_char_t *) "backtrace");
@@ -9141,90 +9137,58 @@ main (void)
 - [jerry_create_external_function](#jerry_create_external_function)
 
 
-## jerry_get_backtrace_from
+## jerry_backtrace_capture
 
 **Summary**
 
-Get backtrace. The backtrace is an array of strings where
+Low-level function to capture each backtrace frame. The captured frame data
-each string contains the position of the corresponding frame.
+is passed to a callback function. To improve performance, the majority of
-The array length is zero if the backtrace is not available.
+the frame data is not initialized when the callback function is called. The
-
+initialization of these fields can be done later by helper functions such
-Collecting the trace starts after the function specified in
+as [jerry_backtrace_get_location](#jerry_backtrace_get_location).
-the `ignored_function` parameter. This parameter can be used to
-skip the helper function(s) which collects the backtrace from
-the backtrace data.
-
-*Notes*:
-- Returned value must be freed with [jerry_release_value](#jerry_release_value) when it
-is no longer needed.
-- This feature depends on build option (`JERRY_LINE_INFO`) and can be checked
-  in runtime with the `JERRY_FEATURE_LINE_INFO` feature enum value,
-  see: [jerry_is_feature_enabled](#jerry_is_feature_enabled).
 
 **Prototype**
 
 ```c
-jerry_value_t
+void
-jerry_get_backtrace_from (uint32_t max_depth, jerry_value_t ignored_function);
+jerry_backtrace_capture (jerry_backtrace_callback_t callback, void *user_p);
 ```
 
-- `max_depth` - backtrace collection stops after reaching this value, 0 = unlimited
+- `callback` - a [jerry_backtrace_callback_t](#jerry_backtrace_callback_t) callback
-- `ignored_function` - if this function is present in the backtrace, the backtrace
+               which is called for each captured frame
-                       only contains the stack frames after the topmost instance of
+- `user_p` - pointer passed to the `callback` function, can be NULL
-                       this function. Otherwise this parameter is ignored
-- return value
-  - a newly constructed JS array
 
-*New in version 2.4*.
+*New in version [[NEXT_RELEASE]]*.
 
 **Example**
 
-[doctest]: # (name="02.API-REFERENCE-jsbacktracefrom.c")
+[doctest]: # (name="02.API-REFERENCE-jscapturebacktrace.c")
 
 ```c
 #include <stdio.h>
 #include <string.h>
 #include "jerryscript.h"
 
+static bool
+backtrace_callback (jerry_backtrace_frame_t *frame_p,
+                    void *user_p)
+{
+  printf (" A stack frame is captured\n");
+  return true;
+}
+
 static jerry_value_t
 backtrace_handler (const jerry_value_t function_obj,
                    const jerry_value_t this_val,
                    const jerry_value_t args_p[],
                    const jerry_length_t args_count)
 {
-  if (!jerry_is_feature_enabled (JERRY_FEATURE_LINE_INFO))
+  (void) function_obj;
-  {
+  (void) this_val;
-    printf ("Line info disabled, no backtrace will be printed\n");
+  (void) args_p;
-    return jerry_create_undefined ();
+  (void) args_count;
-  }
 
-  if (args_count < 1)
+  jerry_backtrace_capture (&backtrace_callback, NULL);
-  {
-    printf ("Ignored function is not specified\n");
-    return jerry_create_undefined ();
-  }
-
-  /* If the line info feature is disabled an empty array will be returned. */
-  jerry_value_t backtrace_array = jerry_get_backtrace_from (0, args_p[0]);
-  uint32_t array_length = jerry_get_array_length (backtrace_array);
-
-  for (uint32_t idx = 0; idx < array_length; idx++)
-  {
-    jerry_value_t property = jerry_get_property_by_index (backtrace_array, idx);
-
-    jerry_char_t string_buffer[64];
-    jerry_size_t copied_bytes = jerry_substring_to_char_buffer (property,
-                                                                0,
-                                                                63,
-                                                                string_buffer,
-                                                                63);
-    string_buffer[copied_bytes] = '\0';
-    printf(" %d: %s\n", idx, string_buffer);
-
-    jerry_release_value (property);
-  }
-
-  jerry_release_value (backtrace_array);
 
   return jerry_create_undefined ();
 } /* backtrace_handler */
@@ -9252,7 +9216,7 @@ main (void)
                         "function g() { h (); }\n"
                         "function h() { backtrace (g); }\n"
                         "f ();\n");
-  const char *resource = "demo_memoryjs";
+  const char *resource = "demo_backtrace.js";
 
   jerry_value_t program = jerry_parse ((const jerry_char_t *) resource,
                                        strlen (resource),
@@ -9275,8 +9239,322 @@ main (void)
 **See also**
 
 - [jerry_get_backtrace](#jerry_get_backtrace)
+- [jerry_backtrace_get_frame_type](#jerry_backtrace_get_frame_type)
+- [jerry_backtrace_get_location](#jerry_backtrace_get_location)
+- [jerry_backtrace_get_function](#jerry_backtrace_get_function)
+- [jerry_backtrace_is_strict](#jerry_backtrace_is_strict)
 
 
+## jerry_backtrace_get_frame_type
+
+**Summary**
+
+Returns with the type of the backtrace frame. This function can only be called
+from the callback function of [jerry_backtrace_capture](#jerry_backtrace_capture),
+and the value becomes invalid after the callback returns.
+
+**Prototype**
+
+```c
+jerry_backtrace_frame_types_t
+jerry_backtrace_get_frame_type (jerry_backtrace_frame_t *frame_p);
+```
+
+- `frame_p` - a frame passed to the [jerry_backtrace_callback_t](#jerry_backtrace_callback_t) callback
+- return value
+  - frame type listed in [jerry_backtrace_frame_types_t](#jerry_backtrace_frame_types_t)
+
+*New in version [[NEXT_RELEASE]]*.
+
+**Example**
+
+See the example of [jerry_backtrace_capture](#jerry_backtrace_capture)
+with the following callback function:
+
+```c
+static bool
+backtrace_callback (jerry_backtrace_frame_t *frame_p,
+                    void *user_p)
+{
+  switch (jerry_backtrace_get_frame_type (frame_p))
+  {
+    case JERRY_BACKTRACE_FRAME_JS:
+    {
+      printf (" ECMAScript frame\n");
+      break;
+    }
+    default:
+    {
+      printf (" Other frame\n");
+      break;
+    }
+  }
+
+  return true;
+}
+```
+
+**See also**
+
+- [jerry_backtrace_capture](#jerry_backtrace_capture)
+
+
+## jerry_backtrace_get_location
+
+**Summary**
+
+Initialize and return with the location private field of a backtrace
+frame. If the location is not available, the returned value is NULL.
+This function can only be called from the callback function of
+[jerry_backtrace_capture](#jerry_backtrace_capture), and the value
+becomes invalid after the callback returns.
+
+*Notes*:
+- Location information can only be retrieved if JERRY_FEATURE_LINE_INFO feature is
+  enabled. Otherwise the function always returns with NULL.
+- The returned data must not be modified, and does not need to be freed.
+  Any cleanup is done automatically after the callback is returned.
+
+**Prototype**
+
+```c
+const jerry_backtrace_location_t *
+jerry_backtrace_get_location (jerry_backtrace_frame_t *frame_p);
+```
+
+- `frame_p` - a frame passed to the [jerry_backtrace_callback_t](#jerry_backtrace_callback_t) callback
+- return value
+  - pointer to the location private field if the location is available,
+  - NULL otherwise
+
+*New in version [[NEXT_RELEASE]]*.
+
+**Example**
+
+See the example of [jerry_backtrace_capture](#jerry_backtrace_capture)
+with the following callback function:
+
+```c
+static bool
+backtrace_callback (jerry_backtrace_frame_t *frame_p,
+                    void *user_p)
+{
+  const jerry_backtrace_location_t *location_p;
+  location_p = jerry_backtrace_get_location (frame_p);
+
+  if (location_p == NULL)
+  {
+    printf ("No location info is available\n");
+    return true;
+  }
+
+  jerry_char_t string_buffer[64];
+  jerry_size_t copied_bytes = jerry_substring_to_char_buffer (location_p->resource_name,
+                                                              0,
+                                                              63,
+                                                              string_buffer,
+                                                              63);
+  string_buffer[copied_bytes] = '\0';
+  printf(" %s:%d:%d\n", string_buffer, (int) location_p->line, (int) location_p->column);
+  return true;
+}
+```
+
+**See also**
+
+- [jerry_backtrace_capture](#jerry_backtrace_capture)
+
+
+## jerry_backtrace_get_function
+
+**Summary**
+
+Initialize and return with the called function private field of a backtrace frame.
+The backtrace frame is created for running the code bound to this function. This
+function can only be called from the callback function of
+[jerry_backtrace_capture](#jerry_backtrace_capture), and the value becomes invalid
+after the callback returns.
+
+*Notes*:
+- The returned data must not be modified, and does not need to be freed.
+  Any cleanup is done automatically after the callback is returned.
+
+**Prototype**
+
+```c
+const jerry_value_t *
+jerry_backtrace_get_function (jerry_backtrace_frame_t *frame_p);
+```
+
+- `frame_p` - a frame passed to the [jerry_backtrace_callback_t](#jerry_backtrace_callback_t) callback
+- return value
+  - pointer to the called function if the function is available,
+  - NULL otherwise
+
+*New in version [[NEXT_RELEASE]]*.
+
+**Example**
+
+See the example of [jerry_backtrace_capture](#jerry_backtrace_capture)
+with the following callback function:
+
+```c
+static bool
+backtrace_callback (jerry_backtrace_frame_t *frame_p,
+                    void *user_p)
+{
+  jerry_value_t *function_p = jerry_backtrace_get_function (frame_p);
+
+  if (function_p != NULL)
+  {
+    printf ("Called function is available");
+    return true;
+  }
+
+  printf ("Called function is NOT available");
+  return true;
+}
+```
+
+**See also**
+
+- [jerry_backtrace_capture](#jerry_backtrace_capture)
+
+
+## jerry_backtrace_is_strict
+
+**Summary**
+
+Returns true, if the code bound to the backtrace frame is strict mode
+code. This function can only be called from the callback function of
+[jerry_backtrace_capture](#jerry_backtrace_capture), and the value
+becomes invalid after the callback returns.
+
+**Prototype**
+
+```c
+bool
+jerry_backtrace_is_strict (jerry_backtrace_frame_t *frame_p);
+```
+
+- `frame_p` - a frame passed to the [jerry_backtrace_callback_t](#jerry_backtrace_callback_t) callback
+- return value
+  - true, if strict mode code is bound to the frame
+  - false, otherwise
+
+*New in version [[NEXT_RELEASE]]*.
+
+**Example**
+
+See the example of [jerry_backtrace_capture](#jerry_backtrace_capture)
+with the following callback function:
+
+```c
+static bool
+backtrace_callback (jerry_backtrace_frame_t *frame_p,
+                    void *user_p)
+{
+  if (jerry_backtrace_is_strict (frame_p))
+  {
+    printf ("Strict mode code is running");
+    return truel
+  }
+
+  printf ("Non-strict mode code is running");
+  return true;
+}
+```
+
+**See also**
+
+- [jerry_backtrace_capture](#jerry_backtrace_capture)
+
+
+# Miscellaneous functions
+
+## jerry_set_vm_exec_stop_callback
+
+**Summary**
+
+When JERRY_FEATURE_VM_EXEC_STOP is enabled a callback function can be
+specified by this function. This callback is periodically called when
+JerryScript executes an ECMAScript program.
+
+If the callback returns with undefined value the ECMAScript execution
+continues. Otherwise the result is thrown by the engine (if the error
+flag is not set for the returned value the engine automatically sets
+it). The callback function might be called again even if it threw
+an error. In this case the function must throw the same error again.
+
+To reduce the CPU overhead of constantly checking the termination
+condition the callback is called when a backward jump is executed
+or an exception is caught. Setting the `frequency` to a greater
+than `1` value reduces this overhead further. If its value is N
+only every Nth event (backward jump, etc.) trigger the next check.
+
+
+**Prototype**
+
+```c
+void
+jerry_set_vm_exec_stop_callback (jerry_vm_exec_stop_callback_t stop_cb,
+                                 void *user_p,
+                                 uint32_t frequency);
+```
+
+- `stop_cb` - periodically called callback (passing NULL disables this feature)
+- `user_p` - user pointer passed to the `stop_cb` function
+- `frequency` - frequency of calling the `stop_cb` function
+
+*New in version 2.0*.
+
+**Example**
+
+[doctest]: # (test="link")
+
+```c
+#include "jerryscript.h"
+
+static int countdown = 10;
+
+static jerry_value_t
+vm_exec_stop_callback (void *user_p)
+{
+  while (countdown > 0)
+  {
+    countdown--;
+    return jerry_create_undefined ();
+  }
+
+  // The error flag is added automatically.
+  return jerry_create_string ((const jerry_char_t *) "Abort script");
+}
+
+int
+main (void)
+{
+  jerry_init (JERRY_INIT_EMPTY);
+
+  jerry_set_vm_exec_stop_callback (vm_exec_stop_callback, &countdown, 16);
+
+  // Infinite loop.
+  const jerry_char_t script[] = "while(true) {}";
+
+  jerry_value_t parsed_code = jerry_parse (NULL, 0, script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
+  jerry_release_value (jerry_run (parsed_code));
+  jerry_release_value (parsed_code);
+  jerry_cleanup ();
+}
+```
+
+**See also**
+
+- [jerry_init](#jerry_init)
+- [jerry_cleanup](#jerry_cleanup)
+- [jerry_parse](#jerry_parse)
+- [jerry_run](#jerry_run)
+- [jerry_vm_exec_stop_callback_t](#jerry_vm_exec_stop_callback_t)
+
 ## jerry_get_resource_name
 
 **Summary**

jerry-core/api/jerry.c

@@ -4681,51 +4681,109 @@ jerry_set_vm_exec_stop_callback (jerry_vm_exec_stop_callback_t stop_cb, /**< per
 jerry_value_t
 jerry_get_backtrace (uint32_t max_depth) /**< depth limit of the backtrace */
 {
-  return vm_get_backtrace (max_depth, NULL);
+  return vm_get_backtrace (max_depth);
 } /* jerry_get_backtrace */
 
 /**
- * Get backtrace. The backtrace is an array of strings where
+ * Low-level function to capture each backtrace frame.
- * each string contains the position of the corresponding frame.
+ * The captured frame data is passed to a callback function.
- * The array length is zero if the backtrace is not available.
- *
- * @return array value
  */
-jerry_value_t
+void
-jerry_get_backtrace_from (uint32_t max_depth, /**< depth limit of the backtrace */
+jerry_backtrace_capture (jerry_backtrace_callback_t callback, /**< callback function */
-                          jerry_value_t ignored_function) /**< collect backtrace after this function */
+                         void *user_p) /**< user pointer passed to the callback function */
 {
-  ecma_object_t *ignored_function_p = NULL;
+  jerry_backtrace_frame_t frame;
+  vm_frame_ctx_t *context_p = JERRY_CONTEXT (vm_top_context_p);
 
-  if (ecma_is_value_object (ignored_function))
+  while (context_p != NULL)
   {
-    ignored_function_p = ecma_get_object_from_value (ignored_function);
+    frame.context_p = context_p;
+    frame.frame_type = JERRY_BACKTRACE_FRAME_JS;
 
-    while (true)
+    if (!callback (&frame, user_p))
     {
-      ecma_object_type_t type = ecma_get_object_type (ignored_function_p);
+      return;
-
-      if (type == ECMA_OBJECT_TYPE_FUNCTION || type == ECMA_OBJECT_TYPE_NATIVE_FUNCTION)
-      {
-        break;
     }
 
-      if (type == ECMA_OBJECT_TYPE_BOUND_FUNCTION)
+    context_p = context_p->prev_context_p;
-      {
-        ecma_bound_function_t *bound_func_p = (ecma_bound_function_t *) ignored_function_p;
-        jmem_cpointer_tag_t target_function = bound_func_p->header.u.bound_function.target_function;
-
-        ignored_function_p = ECMA_GET_NON_NULL_POINTER_FROM_POINTER_TAG (ecma_object_t, target_function);
-        continue;
   }
+} /* jerry_backtrace_capture */
 
-      ignored_function_p = NULL;
+/**
-      break;
+ * Returns with the type of the backtrace frame.
+ *
+ * @return frame type listed in jerry_backtrace_frame_types_t
+ */
+jerry_backtrace_frame_types_t
+jerry_backtrace_get_frame_type (jerry_backtrace_frame_t *frame_p) /**< frame pointer */
+{
+  return (jerry_backtrace_frame_types_t) frame_p->frame_type;
+} /* jerry_backtrace_get_frame_type */
+
+/**
+ * Initialize and return with the location private field of a backtrace frame.
+ *
+ * @return pointer to the location private field - if the location is available,
+ *         NULL - otherwise
+ */
+const jerry_backtrace_location_t *
+jerry_backtrace_get_location (jerry_backtrace_frame_t *frame_p) /**< frame pointer */
+{
+  JERRY_UNUSED (frame_p);
+
+#if ENABLED (JERRY_LINE_INFO)
+  if (frame_p->frame_type == JERRY_BACKTRACE_FRAME_JS)
+  {
+    vm_frame_ctx_t *context_p = frame_p->context_p;
+
+    frame_p->location.resource_name = ecma_get_resource_name (context_p->shared_p->bytecode_header_p);
+    frame_p->location.line = context_p->current_line;
+    frame_p->location.column = 1;
+    return &frame_p->location;
+  }
+#endif /* ENABLED (JERRY_LINE_INFO) */
+
+  return NULL;
+} /* jerry_backtrace_get_location */
+
+/**
+ * Initialize and return with the called function private field of a backtrace frame.
+ * The backtrace frame is created for running the code bound to this function.
+ *
+ * @return pointer to the called function - if the function is available,
+ *         NULL - otherwise
+ */
+const jerry_value_t *
+jerry_backtrace_get_function (jerry_backtrace_frame_t *frame_p) /**< frame pointer */
+{
+  if (frame_p->frame_type == JERRY_BACKTRACE_FRAME_JS)
+  {
+    vm_frame_ctx_t *context_p = frame_p->context_p;
+
+    if (context_p->shared_p->status_flags & VM_FRAME_CTX_SHARED_HAS_ARG_LIST)
+    {
+      vm_frame_ctx_shared_args_t *shared_args_p = (vm_frame_ctx_shared_args_t *) context_p->shared_p;
+
+      frame_p->function = ecma_make_object_value (shared_args_p->function_object_p);
+      return &frame_p->function;
     }
   }
 
-  return vm_get_backtrace (max_depth, ignored_function_p);
+  return NULL;
-} /* jerry_get_backtrace_from */
+} /* jerry_backtrace_get_function */
+
+/**
+ * Returns true, if the code bound to the backtrace frame is strict mode code.
+ *
+ * @return true - if strict mode code is bound to the frame,
+ *         false - otherwise
+ */
+bool
+jerry_backtrace_is_strict (jerry_backtrace_frame_t *frame_p) /**< frame pointer */
+{
+  return (frame_p->frame_type == JERRY_BACKTRACE_FRAME_JS
+          && (frame_p->context_p->status_flags & VM_FRAME_CTX_IS_STRICT) != 0);
+} /* jerry_backtrace_is_strict */
 
 /**
  * Get the resource name (usually a file name) of the currently executed script or the given function object

jerry-core/ecma/operations/ecma-exceptions.c

@@ -177,7 +177,7 @@ ecma_new_standard_error (ecma_standard_error_t error_type, /**< native error typ
                                                                            NULL);
     ecma_deref_ecma_string (stack_str_p);
 
-    ecma_value_t backtrace_value = vm_get_backtrace (0, NULL);
+    ecma_value_t backtrace_value = vm_get_backtrace (0);
 
     prop_value_p->value = backtrace_value;
     ecma_deref_object (ecma_get_object_from_value (backtrace_value));

jerry-core/include/jerryscript-core.h

@@ -205,6 +205,34 @@ typedef struct
   jerry_value_t setter;
 } jerry_property_descriptor_t;
 
+/**
+ * List of backtrace frame types returned by jerry_backtrace_get_frame_type.
+ */
+typedef enum
+{
+  JERRY_BACKTRACE_FRAME_JS, /**< indicates that the frame is created for a JavaScript function/method */
+} jerry_backtrace_frame_types_t;
+
+/**
+ * Location info retreived by jerry_backtrace_get_location.
+ */
+typedef struct
+{
+  jerry_value_t resource_name; /**< resource name */
+  jerry_size_t line; /**< line index */
+  jerry_size_t column; /**< column index */
+} jerry_backtrace_location_t;
+
+/**
+ * Internal data structure for jerry_backtrace_frame_t definition.
+ */
+struct jerry_backtrace_frame_internal_t;
+
+/**
+ * Backtrace frame data passed to the jerry_backtrace_callback_t handler.
+ */
+typedef struct jerry_backtrace_frame_internal_t jerry_backtrace_frame_t;
+
 /**
  * Description of JerryScript heap memory stats.
  * It is for memory profiling.
@@ -237,6 +265,11 @@ typedef void (*jerry_object_native_free_callback_t) (void *native_p);
  */
 typedef void (*jerry_error_object_created_callback_t) (const jerry_value_t error_object, void *user_p);
 
+/**
+ * Callback function which is called by jerry_backtrace_capture for each stack frame.
+ */
+typedef bool (*jerry_backtrace_callback_t) (jerry_backtrace_frame_t *frame_p, void *user_p);
+
 /**
  * Callback which tells whether the ECMAScript execution should be stopped.
  *
@@ -765,12 +798,20 @@ void jerry_heap_free (void *mem_p, size_t size);
  */
 jerry_context_t *jerry_create_context (uint32_t heap_size, jerry_context_alloc_t alloc, void *cb_data_p);
 
+/**
+ * Backtrace functions.
+ */
+jerry_value_t jerry_get_backtrace (uint32_t max_depth);
+void jerry_backtrace_capture (jerry_backtrace_callback_t callback, void *user_p);
+jerry_backtrace_frame_types_t jerry_backtrace_get_frame_type (jerry_backtrace_frame_t *frame_p);
+const jerry_backtrace_location_t *jerry_backtrace_get_location (jerry_backtrace_frame_t *frame_p);
+const jerry_value_t *jerry_backtrace_get_function (jerry_backtrace_frame_t *frame_p);
+bool jerry_backtrace_is_strict (jerry_backtrace_frame_t *frame_p);
+
 /**
  * Miscellaneous functions.
  */
 void jerry_set_vm_exec_stop_callback (jerry_vm_exec_stop_callback_t stop_cb, void *user_p, uint32_t frequency);
-jerry_value_t jerry_get_backtrace (uint32_t max_depth);
-jerry_value_t jerry_get_backtrace_from (uint32_t max_depth, jerry_value_t ignored_function);
 jerry_value_t jerry_get_resource_name (const jerry_value_t value);
 jerry_value_t jerry_get_new_target (void);
 

jerry-core/vm/vm-defines.h

@@ -151,6 +151,17 @@ typedef struct
   vm_frame_ctx_t frame_ctx; /**< frame context part */
 } vm_executable_object_t;
 
+/**
+ * Real backtrace frame data passed to the jerry_backtrace_callback_t handler.
+ */
+struct jerry_backtrace_frame_internal_t
+{
+  vm_frame_ctx_t *context_p; /**< context pointer */
+  uint8_t frame_type; /**< frame type */
+  jerry_backtrace_location_t location; /**< location information */
+  ecma_value_t function; /**< function reference */
+};
+
 /**
  * @}
  * @}

jerry-core/vm/vm-utils.c

@@ -59,40 +59,11 @@ vm_is_direct_eval_form_call (void)
  * @return array ecma value
  */
 ecma_value_t
-vm_get_backtrace (uint32_t max_depth, /**< maximum backtrace depth, 0 = unlimited */
+vm_get_backtrace (uint32_t max_depth) /**< maximum backtrace depth, 0 = unlimited */
-                  ecma_object_t *ignored_function_p) /**< ignore functions up to this function */
 {
 #if ENABLED (JERRY_LINE_INFO)
   vm_frame_ctx_t *context_p = JERRY_CONTEXT (vm_top_context_p);
 
-  if (ignored_function_p != NULL)
-  {
-    JERRY_ASSERT (ecma_get_object_type (ignored_function_p) == ECMA_OBJECT_TYPE_FUNCTION
-                  || ecma_get_object_type (ignored_function_p) == ECMA_OBJECT_TYPE_NATIVE_FUNCTION);
-
-    while (true)
-    {
-      if (context_p == NULL)
-      {
-        context_p = JERRY_CONTEXT (vm_top_context_p);
-        break;
-      }
-
-      if (context_p->shared_p->status_flags & VM_FRAME_CTX_SHARED_HAS_ARG_LIST)
-      {
-        vm_frame_ctx_shared_args_t *shared_args_p = (vm_frame_ctx_shared_args_t *) context_p->shared_p;
-
-        if (shared_args_p->function_object_p == ignored_function_p)
-        {
-          context_p = context_p->prev_context_p;
-          break;
-        }
-      }
-
-      context_p = context_p->prev_context_p;
-    }
-  }
-
   if (max_depth == 0)
   {
     max_depth = UINT32_MAX;
@@ -138,7 +109,6 @@ vm_get_backtrace (uint32_t max_depth, /**< maximum backtrace depth, 0 = unlimite
   return ecma_make_object_value (array_p);
 #else /* !ENABLED (JERRY_LINE_INFO) */
   JERRY_UNUSED (max_depth);
-  JERRY_UNUSED (ignored_function_p);
 
   return ecma_make_object_value (ecma_op_new_array_object (0));
 #endif /* ENABLED (JERRY_LINE_INFO) */

jerry-core/vm/vm.h

@@ -489,7 +489,7 @@ ecma_value_t vm_execute (vm_frame_ctx_t *frame_ctx_p);
 bool vm_is_strict_mode (void);
 bool vm_is_direct_eval_form_call (void);
 
-ecma_value_t vm_get_backtrace (uint32_t max_depth, ecma_object_t *ignored_function_p);
+ecma_value_t vm_get_backtrace (uint32_t max_depth);
 
 /**
  * @}

tests/unit-core/test-backtrace.c

@@ -33,14 +33,109 @@ backtrace_handler (const jerry_value_t function_obj, /**< function object */
     max_depth = (uint32_t) jerry_get_number_value (args_p[0]);
   }
 
-  if (args_count >= 2)
-  {
-    return jerry_get_backtrace_from (max_depth, args_p[1]);
-  }
-
   return jerry_get_backtrace (max_depth);
 } /* backtrace_handler */
 
+static void
+compare_string (jerry_value_t left_value, /* string value */
+                const char *right_p) /* string to compare */
+{
+  jerry_char_t buffer[64];
+  size_t length = strlen (right_p);
+
+  TEST_ASSERT (length <= sizeof (buffer));
+  TEST_ASSERT (jerry_value_is_string (left_value));
+  TEST_ASSERT (jerry_get_string_size (left_value) == length);
+
+  TEST_ASSERT (jerry_string_to_char_buffer (left_value, buffer, sizeof (buffer)) == length);
+  TEST_ASSERT (memcmp (buffer, right_p, length) == 0);
+} /* compare_string */
+
+static const jerry_value_t *handler_args_p;
+static int frame_index;
+
+static bool
+backtrace_callback (jerry_backtrace_frame_t *frame_p, /* frame information */
+                    void *user_p) /* user data */
+{
+  TEST_ASSERT ((void *) handler_args_p == user_p);
+  TEST_ASSERT (jerry_backtrace_get_frame_type (frame_p) == JERRY_BACKTRACE_FRAME_JS);
+
+  const jerry_backtrace_location_t *location_p = jerry_backtrace_get_location (frame_p);
+  const jerry_value_t *function_p = jerry_backtrace_get_function (frame_p);
+
+  TEST_ASSERT (location_p != NULL);
+  TEST_ASSERT (function_p != NULL);
+
+  compare_string (location_p->resource_name, "capture_test.js");
+
+  ++frame_index;
+
+  if (frame_index == 1)
+  {
+    TEST_ASSERT (!jerry_backtrace_is_strict (frame_p));
+    TEST_ASSERT (location_p->line == 2);
+    TEST_ASSERT (location_p->column == 1);
+    TEST_ASSERT (handler_args_p[0] == *function_p);
+    return true;
+  }
+
+  if (frame_index == 2)
+  {
+    TEST_ASSERT (jerry_backtrace_is_strict (frame_p));
+    TEST_ASSERT (location_p->line == 7);
+    TEST_ASSERT (location_p->column == 1);
+    TEST_ASSERT (handler_args_p[1] == *function_p);
+    return true;
+  }
+
+  TEST_ASSERT (frame_index == 3);
+  TEST_ASSERT (!jerry_backtrace_is_strict (frame_p));
+  TEST_ASSERT (location_p->line == 11);
+  TEST_ASSERT (location_p->column == 1);
+  TEST_ASSERT (handler_args_p[2] == *function_p);
+  return false;
+} /* backtrace_callback */
+
+static jerry_value_t
+capture_handler (const jerry_value_t function_obj, /**< function object */
+                 const jerry_value_t this_val, /**< this value */
+                 const jerry_value_t args_p[], /**< argument list */
+                 const jerry_length_t args_count) /**< argument count */
+{
+  JERRY_UNUSED (function_obj);
+  JERRY_UNUSED (this_val);
+  JERRY_UNUSED (args_p);
+  JERRY_UNUSED (args_count);
+
+  TEST_ASSERT (args_count == 3);
+
+  frame_index = 0;
+  handler_args_p = args_p;
+  jerry_backtrace_capture (backtrace_callback, (void *) args_p);
+  TEST_ASSERT (frame_index == 3);
+
+  return jerry_create_undefined ();
+} /* capture_handler */
+
+static void
+register_callback (jerry_external_handler_t handler_p, /**< callback function */
+                   char *name_p) /**< name of the function */
+{
+  jerry_value_t global = jerry_get_global_object ();
+
+  jerry_value_t func = jerry_create_external_function (handler_p);
+  jerry_value_t name = jerry_create_string ((const jerry_char_t *) name_p);
+  jerry_value_t result = jerry_set_property (global, name, func);
+  TEST_ASSERT (!jerry_value_is_error (result));
+
+  jerry_release_value (result);
+  jerry_release_value (name);
+  jerry_release_value (func);
+
+  jerry_release_value (global);
+} /* register_callback */
+
 static jerry_value_t
 run (const char *resource_name_p, /**< resource name */
      const char *source_p) /**< source code */
@@ -89,18 +184,8 @@ test_get_backtrace_api_call (void)
 {
   jerry_init (JERRY_INIT_EMPTY);
 
-  jerry_value_t global = jerry_get_global_object ();
+  register_callback (backtrace_handler, "backtrace");
-
+  register_callback (capture_handler, "capture");
-  jerry_value_t func = jerry_create_external_function (backtrace_handler);
-  jerry_value_t name = jerry_create_string ((const jerry_char_t *) "backtrace");
-  jerry_value_t result = jerry_set_property (global, name, func);
-  TEST_ASSERT (!jerry_value_is_error (result));
-
-  jerry_release_value (result);
-  jerry_release_value (name);
-  jerry_release_value (func);
-
-  jerry_release_value (global);
 
   const char *source = ("function f() {\n"
                         "  return backtrace(0);\n"
@@ -158,13 +243,14 @@ test_get_backtrace_api_call (void)
 
   jerry_release_value (backtrace);
 
-  /* Ignore f and g this time. */
+  /* Test frame capturing. */
 
   source = ("function f() {\n"
-            "  return backtrace(0, g);\n"
+            "  return capture(f, g, h);\n"
             "}\n"
             "\n"
             "function g() {\n"
+            "  'use strict';\n"
             "  return f();\n"
             "}\n"
             "\n"
@@ -174,77 +260,9 @@ test_get_backtrace_api_call (void)
             "\n"
             "h();\n");
 
-  backtrace = run ("something_ignore.js", source);
+  backtrace = run ("capture_test.js", source);
-
-  TEST_ASSERT (!jerry_value_is_error (backtrace)
-               && jerry_value_is_array (backtrace));
-
-  TEST_ASSERT (jerry_get_array_length (backtrace) == 2);
-
-  compare (backtrace, 0, "something_ignore.js:10");
-  compare (backtrace, 1, "something_ignore.js:13");
-
-  jerry_release_value (backtrace);
-
-  /* Use bound function this time. */
-
-  source = ("function f() {\n"
-            "  return backtrace(0, i);\n"
-            "}\n"
-            "\n"
-            "function g(u, v) {\n"
-            "  return v();\n"
-            "}\n"
-            "\n"
-            "var h = g.bind(null, 0)\n"
-            "var i = h.bind(null, f)\n"
-            "\n"
-            "function j() {\n"
-            "  return i();\n"
-            "}\n"
-            "\n"
-            "j();\n");
-
-  backtrace = run ("something_bound.js", source);
-
-  TEST_ASSERT (!jerry_value_is_error (backtrace)
-               && jerry_value_is_array (backtrace));
-
-  TEST_ASSERT (jerry_get_array_length (backtrace) == 2);
-
-  compare (backtrace, 0, "something_bound.js:13");
-  compare (backtrace, 1, "something_bound.js:16");
-
-  jerry_release_value (backtrace);
-
-  /* Use invalid function this time. */
-
-  source = ("function f() {\n"
-            "  return backtrace(0, ':)');\n"
-            "}\n"
-            "\n"
-            "function g() {\n"
-            "  return f();\n"
-            "}\n"
-            "\n"
-            "function h() {\n"
-            "  return g();\n"
-            "}\n"
-            "\n"
-            "h();\n");
-
-  backtrace = run ("nothing_ignore.js", source);
-
-  TEST_ASSERT (!jerry_value_is_error (backtrace)
-               && jerry_value_is_array (backtrace));
-
-  TEST_ASSERT (jerry_get_array_length (backtrace) == 4);
-
-  compare (backtrace, 0, "nothing_ignore.js:2");
-  compare (backtrace, 1, "nothing_ignore.js:6");
-  compare (backtrace, 2, "nothing_ignore.js:10");
-  compare (backtrace, 3, "nothing_ignore.js:13");
 
+  TEST_ASSERT (jerry_value_is_undefined (backtrace));
   jerry_release_value (backtrace);
 
   jerry_cleanup ();