Support multiple primary functions in a single snapshot.

This patch adds an extension to snapshots which allows storing
multiple position independent primary functions in a single
snapshot data. A new application called jerry-snapshot is
added to the project to manage snapshots. Currently the only
option is merging snapshots.

JerryScript-DCO-1.0-Signed-off-by: Zoltan Herczeg [email protected]

Author: zherczeg

CMakeLists.txt

@@ -23,13 +23,14 @@ string(TOUPPER "${PLATFORM}" PLATFORM)
 set(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS )
 
 # Components
-set(JERRY_CMDLINE         ON  CACHE BOOL "Build jerry command line tool?")
-set(JERRY_CMDLINE_MINIMAL OFF CACHE BOOL "Build jerry minimal command line tool?")
-set(JERRY_PORT_DEFAULT    ON  CACHE BOOL "Build default jerry port implementation?")
-set(JERRY_EXT             ON  CACHE BOOL "Build jerry-ext?")
-set(JERRY_LIBC            ON  CACHE BOOL "Build and use jerry-libc?")
-set(JERRY_LIBM            ON  CACHE BOOL "Build and use jerry-libm?")
-set(UNITTESTS             OFF CACHE BOOL "Build unit tests?")
+set(JERRY_CMDLINE          ON  CACHE BOOL "Build jerry command line tool?")
+set(JERRY_CMDLINE_MINIMAL  OFF CACHE BOOL "Build jerry minimal command line tool?")
+set(JERRY_CMDLINE_SNAPSHOT OFF CACHE BOOL "Build jerry snapshot command line tool?")
+set(JERRY_PORT_DEFAULT     ON  CACHE BOOL "Build default jerry port implementation?")
+set(JERRY_EXT              ON  CACHE BOOL "Build jerry-ext?")
+set(JERRY_LIBC             ON  CACHE BOOL "Build and use jerry-libc?")
+set(JERRY_LIBM             ON  CACHE BOOL "Build and use jerry-libm?")
+set(UNITTESTS              OFF CACHE BOOL "Build unit tests?")
 
 # Optional build settings
 set(ENABLE_ALL_IN_ONE  OFF CACHE BOOL "Enable all-in-one build?")
@@ -41,7 +42,7 @@ if(NOT CMAKE_BUILD_TYPE)
   set(CMAKE_BUILD_TYPE "MinSizeRel")
 endif()
 
-if(JERRY_CMDLINE OR JERRY_CMDLINE_MINIMAL)
+if(JERRY_CMDLINE OR JERRY_CMDLINE_MINIMAL OR JERRY_CMDLINE_SNAPSHOT)
   set(JERRY_PORT_DEFAULT "ON")
 
   set(JERRY_PORT_DEFAULT_MESSAGE " (FORCED BY CMDLINE)")
@@ -100,6 +101,7 @@ message(STATUS "ENABLE_STATIC_LINK        " ${ENABLE_STATIC_LINK} ${ENABLE_STATI
 message(STATUS "ENABLE_STRIP              " ${ENABLE_STRIP} ${ENABLE_STRIP_MESSAGE})
 message(STATUS "JERRY_CMDLINE             " ${JERRY_CMDLINE})
 message(STATUS "JERRY_CMDLINE_MINIMAL     " ${JERRY_CMDLINE_MINIMAL})
+message(STATUS "JERRY_CMDLINE_SNAPSHOT    " ${JERRY_CMDLINE_SNAPSHOT})
 message(STATUS "JERRY_PORT_DEFAULT        " ${JERRY_PORT_DEFAULT} ${JERRY_PORT_DEFAULT_MESSAGE})
 message(STATUS "JERRY_EXT                 " ${JERRY_EXT} ${JERRY_EXT_MESSAGE})
 message(STATUS "JERRY_LIBC                " ${JERRY_LIBC} ${JERRY_LIBC_MESSAGE})
@@ -252,7 +254,7 @@ if(JERRY_EXT)
 endif()
 
 # Jerry command line tool
-if(JERRY_CMDLINE OR JERRY_CMDLINE_MINIMAL)
+if(JERRY_CMDLINE OR JERRY_CMDLINE_MINIMAL OR JERRY_CMDLINE_SNAPSHOT)
   add_subdirectory(jerry-main)
 endif()
 

docs/02.API-REFERENCE.md

@@ -4012,9 +4012,9 @@ jerry_exec_snapshot (const uint32_t *snapshot_p,
 
   jerry_init (JERRY_INIT_EMPTY);
 
-  res = (jerry_exec_snapshot (global_mode_snapshot_buffer,
-                              global_mode_snapshot_size,
-                              false);
+  res = jerry_exec_snapshot (global_mode_snapshot_buffer,
+                             global_mode_snapshot_size,
+                             false);
 
   jerry_cleanup ();
 }
@@ -4024,6 +4024,76 @@ jerry_exec_snapshot (const uint32_t *snapshot_p,
 
 - [jerry_init](#jerry_init)
 - [jerry_cleanup](#jerry_cleanup)
+- [jerry_exec_snapshot_at](#jerry_exec_snapshot_at)
+- [jerry_parse_and_save_snapshot](#jerry_parse_and_save_snapshot)
+
+
+## jerry_exec_snapshot_at
+
+**Summary**
+
+Execute the selected snapshot function from the specified buffer.
+
+Same function as [jerry_exec_snapshot](#jerry_exec_snapshot) except
+the executed function index can be specified.
+
+*Note*: Returned value must be freed with [jerry_release_value](#jerry_release_value) when it
+is no longer needed.
+
+**Prototype**
+
+```c
+jerry_value_t
+jerry_exec_snapshot_at (const uint32_t *snapshot_p,
+                        size_t snapshot_size,
+                        size_t func_index,
+                        bool copy_bytecode);
+```
+
+- `snapshot_p` - pointer to snapshot
+- `snapshot_size` - size of snapshot
+- `func_index` - index of executed function
+- `copy_bytecode` - flag, indicating whether the passed snapshot buffer should be copied to the
+   engine's memory. If set the engine should not reference the buffer after the function returns
+   (in this case, the passed buffer could be freed after the call). Otherwise (if the flag is not
+   set) - the buffer could only be freed after the engine stops (i.e. after call to jerry_cleanup).
+- return value
+  - result of bytecode, if run was successful
+  - thrown error, otherwise
+
+**Example**
+
+```c
+{
+  jerry_value_t res;
+  static uint32_t global_mode_snapshot_buffer[256];
+  const jerry_char_t *code_to_snapshot_p = "(function () { return 'string from snapshot'; }) ();";
+
+  jerry_init (JERRY_INIT_EMPTY);
+  size_t global_mode_snapshot_size = jerry_parse_and_save_snapshot (code_to_snapshot_p,
+                                                                    strlen ((const char *) code_to_snapshot_p),
+                                                                    true,
+                                                                    false,
+                                                                    global_mode_snapshot_buffer,
+                                                                    sizeof (global_mode_snapshot_buffer) / sizeof (uint32_t));
+  jerry_cleanup ();
+
+  jerry_init (JERRY_INIT_EMPTY);
+
+  res = jerry_exec_snapshot_at (global_mode_snapshot_buffer,
+                                global_mode_snapshot_size,
+                                0,
+                                false);
+
+  jerry_cleanup ();
+}
+```
+
+**See also**
+
+- [jerry_init](#jerry_init)
+- [jerry_cleanup](#jerry_cleanup)
+- [jerry_exec_snapshot](#jerry_exec_snapshot)
 - [jerry_parse_and_save_snapshot](#jerry_parse_and_save_snapshot)
 
 

jerry-core/api/jerry-snapshot.c

@@ -91,7 +91,10 @@ snapshot_add_compiled_code (ecma_compiled_code_t *compiled_code_p, /**< compiled
     return 0;
   }
 
-  uint16_t start_offset = (uint16_t) (globals_p->snapshot_buffer_write_offset >> JMEM_ALIGNMENT_LOG);
+  /* The snapshot generator always parses a single file,
+   * so the base always starts right after the snapshot header. */
+  size_t buffer_offset = globals_p->snapshot_buffer_write_offset - sizeof (jerry_snapshot_header_t);
+  uint16_t start_offset = (uint16_t) (buffer_offset >> JMEM_ALIGNMENT_LOG);
 
   uint8_t *copied_code_start_p = snapshot_buffer_p + globals_p->snapshot_buffer_write_offset;
   ecma_compiled_code_t *copied_code_p = (ecma_compiled_code_t *) copied_code_start_p;
@@ -252,10 +255,10 @@ jerry_snapshot_set_offsets (uint32_t *buffer_p, /**< buffer */
       {
         for (uint32_t i = 0; i < argument_end; i++)
         {
-          lit_mem_to_snapshot_id_map_entry_t *current_p = lit_map_p;
-
           if (literal_start_p[i] != JMEM_CP_NULL)
           {
+            lit_mem_to_snapshot_id_map_entry_t *current_p = lit_map_p;
+
             while (current_p->literal_id != literal_start_p[i])
             {
               current_p++;
@@ -316,12 +319,14 @@ jerry_snapshot_set_offsets (uint32_t *buffer_p, /**< buffer */
  * @return byte code
  */
 static ecma_compiled_code_t *
-snapshot_load_compiled_code (const uint8_t *snapshot_data_p, /**< snapshot data */
+snapshot_load_compiled_code (const uint8_t *base_addr_p, /**< base address of the
+                                                          *   current primary function */
                              size_t offset, /**< byte code offset */
-                             lit_mem_to_snapshot_id_map_entry_t *lit_map_p, /**< literal map */
+                             const uint8_t *literal_base_p, /**< literal start */
+                             const uint8_t *number_base_p, /**< literal number start */
                              bool copy_bytecode) /**< byte code should be copied to memory */
 {
-  ecma_compiled_code_t *bytecode_p = (ecma_compiled_code_t *) (snapshot_data_p + offset);
+  ecma_compiled_code_t *bytecode_p = (ecma_compiled_code_t *) (base_addr_p + offset);
   uint32_t code_size = ((uint32_t) bytecode_p->size) << JMEM_ALIGNMENT_LOG;
 
   if (!(bytecode_p->status_flags & CBC_CODE_FLAGS_FUNCTION))
@@ -377,7 +382,7 @@ snapshot_load_compiled_code (const uint8_t *snapshot_data_p, /**< snapshot data
     jmem_stats_allocate_byte_code_bytes (code_size);
 #endif /* JMEM_STATS */
 
-    memcpy (bytecode_p, snapshot_data_p + offset, code_size);
+    memcpy (bytecode_p, base_addr_p + offset, code_size);
   }
   else
   {
@@ -392,7 +397,7 @@ snapshot_load_compiled_code (const uint8_t *snapshot_data_p, /**< snapshot data
     jmem_stats_allocate_byte_code_bytes (total_size);
 #endif /* JMEM_STATS */
 
-    memcpy (bytecode_p, snapshot_data_p + offset, code_size);
+    memcpy (bytecode_p, base_addr_p + offset, code_size);
 
     bytecode_p->size = (uint16_t) (total_size >> JMEM_ALIGNMENT_LOG);
 
@@ -412,17 +417,9 @@ snapshot_load_compiled_code (const uint8_t *snapshot_data_p, /**< snapshot data
 
   for (uint32_t i = 0; i < const_literal_end; i++)
   {
-    lit_mem_to_snapshot_id_map_entry_t *current_p = lit_map_p;
-
-    if (literal_start_p[i] != 0)
-    {
-      while (current_p->literal_offset != literal_start_p[i])
-      {
-        current_p++;
-      }
-
-      literal_start_p[i] = current_p->literal_id;
-    }
+    literal_start_p[i] = ecma_snapshot_get_literal (literal_base_p,
+                                                    number_base_p,
+                                                    literal_start_p[i]);
   }
 
   for (uint32_t i = const_literal_end; i < literal_end; i++)
@@ -438,9 +435,10 @@ snapshot_load_compiled_code (const uint8_t *snapshot_data_p, /**< snapshot data
     else
     {
       ecma_compiled_code_t *literal_bytecode_p;
-      literal_bytecode_p = snapshot_load_compiled_code (snapshot_data_p,
+      literal_bytecode_p = snapshot_load_compiled_code (base_addr_p,
                                                         literal_offset,
-                                                        lit_map_p,
+                                                        literal_base_p,
+                                                        number_base_p,
                                                         copy_bytecode);
 
       ECMA_SET_NON_NULL_POINTER (literal_start_p[i],
@@ -500,7 +498,13 @@ jerry_parse_and_save_snapshot (const jerry_char_t *source_p, /**< script source
   jerry_snapshot_header_t header;
   header.version = JERRY_SNAPSHOT_VERSION;
   header.lit_table_offset = (uint32_t) globals.snapshot_buffer_write_offset;
-  header.is_run_global = is_for_global;
+  header.number_of_funcs = 1;
+  header.func_offsets[0] = sizeof (jerry_snapshot_header_t);
+
+  if (!is_for_global)
+  {
+    header.func_offsets[0] |= JERRY_SNAPSHOT_EVAL_CONTEXT;
+  }
 
   lit_mem_to_snapshot_id_map_entry_t *lit_map_p = NULL;
   uint32_t literals_num;
@@ -509,8 +513,7 @@ jerry_parse_and_save_snapshot (const jerry_char_t *source_p, /**< script source
                                         buffer_size,
                                         &globals.snapshot_buffer_write_offset,
                                         &lit_map_p,
-                                        &literals_num,
-                                        &header.lit_table_size))
+                                        &literals_num))
   {
     JERRY_ASSERT (lit_map_p == NULL);
     return 0;
@@ -559,15 +562,16 @@ jerry_parse_and_save_snapshot (const jerry_char_t *source_p, /**< script source
  *         thrown error - otherwise
  */
 jerry_value_t
-jerry_exec_snapshot (const uint32_t *snapshot_p, /**< snapshot */
-                     size_t snapshot_size, /**< size of snapshot */
-                     bool copy_bytecode) /**< flag, indicating whether the passed snapshot
-                                          *   buffer should be copied to the engine's memory.
-                                          *   If set the engine should not reference the buffer
-                                          *   after the function returns (in this case, the passed
-                                          *   buffer could be freed after the call).
-                                          *   Otherwise (if the flag is not set) - the buffer could only be
-                                          *   freed after the engine stops (i.e. after call to jerry_cleanup). */
+jerry_exec_snapshot_at (const uint32_t *snapshot_p, /**< snapshot */
+                        size_t snapshot_size, /**< size of snapshot */
+                        size_t func_index, /**< index of primary function */
+                        bool copy_bytecode) /**< flag, indicating whether the passed snapshot
+                                             *   buffer should be copied to the engine's memory.
+                                             *   If set the engine should not reference the buffer
+                                             *   after the function returns (in this case, the passed
+                                             *   buffer could be freed after the call).
+                                             *   Otherwise (if the flag is not set) - the buffer could only be
+                                             *   freed after the engine stops (i.e. after call to jerry_cleanup). */
 {
 #ifdef JERRY_ENABLE_SNAPSHOT_EXEC
   JERRY_ASSERT (snapshot_p != NULL);
@@ -588,34 +592,32 @@ jerry_exec_snapshot (const uint32_t *snapshot_p, /**< snapshot */
     return ecma_raise_type_error (invalid_version_error_p);
   }
 
-  lit_mem_to_snapshot_id_map_entry_t *lit_map_p = NULL;
-  uint32_t literals_num;
-
   if (header_p->lit_table_offset >= snapshot_size)
   {
     return ecma_raise_type_error (invalid_version_error_p);
   }
 
-  JERRY_ASSERT ((header_p->lit_table_offset % sizeof (uint32_t)) == 0);
-  if (!ecma_load_literals_from_snapshot ((uint32_t *) (snapshot_data_p + header_p->lit_table_offset),
-                                         header_p->lit_table_size,
-                                         &lit_map_p,
-                                         &literals_num))
+  if (func_index >= header_p->number_of_funcs)
   {
-    JERRY_ASSERT (lit_map_p == NULL);
-    return ecma_raise_type_error (invalid_format_error_p);
+    return ecma_raise_range_error (ECMA_ERR_MSG ("Function index is higher than maximum"));
   }
 
+  JERRY_ASSERT ((header_p->lit_table_offset % sizeof (uint32_t)) == 0);
+
+  const uint8_t *literal_base_p;
+  const uint8_t *number_base_p;
+
+  literal_base_p = ecma_snapshot_get_literals_base ((uint32_t *) (snapshot_data_p + header_p->lit_table_offset),
+                                                    &number_base_p);
+
   ecma_compiled_code_t *bytecode_p;
-  bytecode_p = snapshot_load_compiled_code (snapshot_data_p,
-                                            sizeof (jerry_snapshot_header_t),
-                                            lit_map_p,
-                                            copy_bytecode);
 
-  if (lit_map_p != NULL)
-  {
-    jmem_heap_free_block (lit_map_p, literals_num * sizeof (lit_mem_to_snapshot_id_map_entry_t));
-  }
+  uint32_t func_offset = header_p->func_offsets[func_index] & ~JERRY_SNAPSHOT_EVAL_CONTEXT;
+  bytecode_p = snapshot_load_compiled_code (snapshot_data_p + func_offset,
+                                            0,
+                                            literal_base_p,
+                                            number_base_p,
+                                            copy_bytecode);
 
   if (bytecode_p == NULL)
   {
@@ -624,17 +626,49 @@ jerry_exec_snapshot (const uint32_t *snapshot_p, /**< snapshot */
 
   ecma_value_t ret_val;
 
-  if (header_p->is_run_global)
+  if (header_p->func_offsets[func_index] & JERRY_SNAPSHOT_EVAL_CONTEXT)
   {
-    ret_val = vm_run_global (bytecode_p);
-    ecma_bytecode_deref (bytecode_p);
+    ret_val = vm_run_eval (bytecode_p, false);
   }
   else
   {
-    ret_val = vm_run_eval (bytecode_p, false);
+    ret_val = vm_run_global (bytecode_p);
+    ecma_bytecode_deref (bytecode_p);
   }
 
   return ret_val;
+#else /* !JERRY_ENABLE_SNAPSHOT_EXEC */
+  JERRY_UNUSED (snapshot_p);
+  JERRY_UNUSED (snapshot_size);
+  JERRY_UNUSED (func_index);
+  JERRY_UNUSED (copy_bytecode);
+
+  return ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE);
+#endif /* JERRY_ENABLE_SNAPSHOT_EXEC */
+} /* jerry_exec_snapshot_at */
+
+/**
+ * Execute snapshot from specified buffer
+ *
+ * Note:
+ *      returned value must be freed with jerry_release_value, when it is no longer needed.
+ *
+ * @return result of bytecode - if run was successful
+ *         thrown error - otherwise
+ */
+jerry_value_t
+jerry_exec_snapshot (const uint32_t *snapshot_p, /**< snapshot */
+                     size_t snapshot_size, /**< size of snapshot */
+                     bool copy_bytecode) /**< flag, indicating whether the passed snapshot
+                                          *   buffer should be copied to the engine's memory.
+                                          *   If set the engine should not reference the buffer
+                                          *   after the function returns (in this case, the passed
+                                          *   buffer could be freed after the call).
+                                          *   Otherwise (if the flag is not set) - the buffer could only be
+                                          *   freed after the engine stops (i.e. after call to jerry_cleanup). */
+{
+#ifdef JERRY_ENABLE_SNAPSHOT_EXEC
+  return jerry_exec_snapshot_at (snapshot_p, snapshot_size, 0, copy_bytecode);
 #else /* !JERRY_ENABLE_SNAPSHOT_EXEC */
   JERRY_UNUSED (snapshot_p);
   JERRY_UNUSED (snapshot_size);