Parser optimizations.

 - parser is now non-recursive (i.e. parse function is not called recursively in any case);
 - byte-code is now more compact:
    - constants are now not immediately dumped upon occurence, but later - where necessary;
    - assignments are combined with unary / binary operations;
    - binary operations are encoded more compactly in many cases;
 - byte-code arrays are now allocated separately for each scope (so, GC of the scopes now becomes possible);
 - byte-code is dumped directly into corresponding byte-code arrays:
   - linked lists of op_meta are not now used for main code of a scope.

JerryScript-DCO-1.0-Signed-off-by: Ruben Ayrapetyan r.ayrapetyan@samsung.com
JerryScript-DCO-1.0-Signed-off-by: Andrey Shitov a.shitov@samsung.com

Author: sand1k

jerry-core/CMakeLists.txt

@@ -112,6 +112,7 @@ project (JerryCore CXX C ASM)
      ${CMAKE_SOURCE_DIR}/jerry-core/ecma/base
      ${CMAKE_SOURCE_DIR}/jerry-core/ecma/operations
      ${CMAKE_SOURCE_DIR}/jerry-core/parser/js
+     ${CMAKE_SOURCE_DIR}/jerry-core/parser/js/bc
      ${CMAKE_SOURCE_DIR}/jerry-core/parser/js/collections
      ${CMAKE_SOURCE_DIR}/jerry-core/parser/regexp
      ${CMAKE_SOURCE_DIR}/jerry-core/jrt)
@@ -131,6 +132,7 @@ project (JerryCore CXX C ASM)
   file(GLOB SOURCE_CORE_ECMA_BASE             ecma/base/*.cpp)
   file(GLOB SOURCE_CORE_ECMA_OPERATIONS       ecma/operations/*.cpp)
   file(GLOB SOURCE_CORE_PARSER_JS             parser/js/*.cpp)
+  file(GLOB SOURCE_CORE_PARSER_JS_BC          parser/js/bc/*.cpp)
   file(GLOB SOURCE_CORE_PARSER_JS_COLLECTIONS parser/js/collections/*.cpp)
   file(GLOB SOURCE_CORE_PARSER_REGEXP         parser/regexp/*.cpp)
   file(GLOB SOURCE_CORE_JRT                   jrt/*.cpp)
@@ -145,6 +147,7 @@ project (JerryCore CXX C ASM)
       ${SOURCE_CORE_ECMA_BASE}
       ${SOURCE_CORE_ECMA_OPERATIONS}
       ${SOURCE_CORE_PARSER_JS}
+      ${SOURCE_CORE_PARSER_JS_BC}
       ${SOURCE_CORE_PARSER_JS_COLLECTIONS}
       ${SOURCE_CORE_PARSER_REGEXP}
       ${SOURCE_CORE_JRT})

jerry-core/ecma/base/ecma-globals.h

@@ -795,6 +795,8 @@ FIXME (Move to library that should define the type (literal.h /* ? */))
 typedef rcs_record_t *literal_t;
 typedef rcs_cpointer_t lit_cpointer_t;
 
+#define NOT_A_LITERAL (lit_cpointer_t::null_cp ())
+
 /**
  * ECMA string-value descriptor
  */

jerry-core/ecma/base/ecma-helpers-string.cpp

@@ -20,6 +20,7 @@
  * @{
  */
 
+#include "bytecode-data.h"
 #include "ecma-alloc.h"
 #include "ecma-gc.h"
 #include "ecma-globals.h"
@@ -29,7 +30,6 @@
 #include "jrt-libc-includes.h"
 #include "lit-char-helpers.h"
 #include "lit-magic-strings.h"
-#include "serializer.h"
 #include "vm.h"
 
 /**

jerry-core/ecma/builtin-objects/ecma-builtin-function.cpp

@@ -21,7 +21,6 @@
 #include "ecma-function-object.h"
 #include "ecma-lex-env.h"
 #include "ecma-try-catch-macro.h"
-#include "serializer.h"
 #include "lit-magic-strings.h"
 #include "parser.h"
 

jerry-core/ecma/operations/ecma-eval.cpp

@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 
+#include "bytecode-data.h"
 #include "ecma-builtins.h"
 #include "ecma-exceptions.h"
 #include "ecma-eval.h"
@@ -21,7 +22,6 @@
 #include "ecma-helpers.h"
 #include "ecma-lex-env.h"
 #include "parser.h"
-#include "serializer.h"
 #include "vm.h"
 
 /** \addtogroup ecma ECMA
@@ -114,7 +114,7 @@ ecma_op_eval_chars_buffer (const jerry_api_char_t *code_p, /**< code characters
 
     if (!code_contains_functions)
     {
-      serializer_remove_bytecode_data (bytecode_data_p);
+      bc_remove_bytecode_data (bytecode_data_p);
     }
   }
 

jerry-core/ecma/operations/ecma-function-object.cpp

@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 
+#include "bytecode-data.h"
 #include "ecma-alloc.h"
 #include "ecma-builtin-helpers.h"
 #include "ecma-builtins.h"
@@ -255,28 +256,27 @@ ecma_op_create_function_object (ecma_collection_header_t *formal_params_collecti
   bool is_no_lex_env = false;
 
   vm_instr_counter_t instr_pos = first_instr_pos;
-  opcode_scope_code_flags_t scope_flags = vm_get_scope_flags (bytecode_header_p, instr_pos++);
 
-  if (scope_flags & OPCODE_SCOPE_CODE_FLAGS_STRICT)
+  if (bytecode_header_p->is_strict)
   {
     is_strict_mode_code = true;
   }
 
-  if ((scope_flags & OPCODE_SCOPE_CODE_FLAGS_NOT_REF_ARGUMENTS_IDENTIFIER)
-      && (scope_flags & OPCODE_SCOPE_CODE_FLAGS_NOT_REF_EVAL_IDENTIFIER))
+  if (!bytecode_header_p->is_ref_arguments_identifier
+      && !bytecode_header_p->is_ref_eval_identifier)
   {
     /* the code doesn't use 'arguments' identifier
      * and doesn't perform direct call to eval,
      * so Arguments object can't be referenced */
     do_instantiate_arguments_object = false;
   }
 
-  if (scope_flags & OPCODE_SCOPE_CODE_FLAGS_ARGUMENTS_ON_REGISTERS)
+  if (bytecode_header_p->is_args_moved_to_regs)
   {
     is_arguments_moved_to_regs = true;
   }
 
-  if (scope_flags & OPCODE_SCOPE_CODE_FLAGS_NO_LEX_ENV)
+  if (bytecode_header_p->is_no_lex_env)
   {
     is_no_lex_env = true;
   }

jerry-core/jerry-internal.h

@@ -38,8 +38,7 @@ jerry_is_abort_on_fail (void);
 typedef struct
 {
   uint32_t lit_table_size; /**< size of literal table */
-  uint32_t bytecode_size; /**< size of instructions array */
-  uint32_t idx_to_lit_map_size; /** size of idx-to-lit map */
+  uint32_t scopes_num; /**< number of saved bytecode pieces in the snapshot */
   uint32_t is_run_global : 1; /**< flag, indicating whether the snapshot
                                *   was dumped as 'Global scope'-mode code (true)
                                *   or as eval-mode code (false) */
@@ -48,6 +47,6 @@ typedef struct
 /**
  * Jerry snapshot format version
  */
-#define JERRY_SNAPSHOT_VERSION (1u)
+#define JERRY_SNAPSHOT_VERSION (2u)
 
 #endif /* !JERRY_INTERNAL_H */

jerry-core/jerry.cpp

@@ -15,6 +15,7 @@
 
 #include <stdio.h>
 
+#include "bytecode-data.h"
 #include "ecma-alloc.h"
 #include "ecma-array-object.h"
 #include "ecma-builtins.h"
@@ -27,9 +28,9 @@
 #include "ecma-objects.h"
 #include "ecma-objects-general.h"
 #include "ecma-try-catch-macro.h"
+#include "lit-literal.h"
 #include "lit-magic-strings.h"
 #include "parser.h"
-#include "serializer.h"
 
 #define JERRY_INTERNAL
 #include "jerry-internal.h"
@@ -1420,7 +1421,7 @@ jerry_init (jerry_flag_t flags) /**< combination of Jerry flags */
   jerry_make_api_available ();
 
   mem_init ();
-  serializer_init ();
+  lit_init ();
   ecma_init ();
 } /* jerry_init */
 
@@ -1435,7 +1436,8 @@ jerry_cleanup (void)
   bool is_show_mem_stats = ((jerry_flags & JERRY_FLAG_MEM_STATS) != 0);
 
   ecma_finalize ();
-  serializer_free ();
+  lit_finalize ();
+  bc_finalize ();
   mem_finalize (is_show_mem_stats);
   vm_finalize ();
 } /* jerry_cleanup */
@@ -1684,11 +1686,11 @@ jerry_parse_and_save_snapshot (const jerry_api_char_t* source_p, /**< script sou
 
   size_t header_offset = buffer_write_offset;
 
-  if (buffer_write_offset + sizeof (jerry_snapshot_header_t) > buffer_size)
+  if (buffer_write_offset + JERRY_ALIGNUP (sizeof (jerry_snapshot_header_t), MEM_ALIGNMENT) > buffer_size)
   {
     return 0;
   }
-  buffer_write_offset += sizeof (jerry_snapshot_header_t);
+  buffer_write_offset += JERRY_ALIGNUP (sizeof (jerry_snapshot_header_t), MEM_ALIGNMENT);
 
   lit_mem_to_snapshot_id_map_entry_t* lit_map_p = NULL;
   uint32_t literals_num;
@@ -1704,17 +1706,21 @@ jerry_parse_and_save_snapshot (const jerry_api_char_t* source_p, /**< script sou
     return 0;
   }
 
-  size_t bytecode_offset = sizeof (version) + sizeof (jerry_snapshot_header_t) + header.lit_table_size;
+  size_t bytecode_offset = (sizeof (version)
+                            + JERRY_ALIGNUP (sizeof (jerry_snapshot_header_t), MEM_ALIGNMENT)
+                            + header.lit_table_size);
+
   JERRY_ASSERT (JERRY_ALIGNUP (bytecode_offset, MEM_ALIGNMENT) == bytecode_offset);
 
-  bool is_ok = serializer_dump_bytecode_with_idx_map (buffer_p,
-                                                      buffer_size,
-                                                      &buffer_write_offset,
-                                                      bytecode_data_p,
-                                                      lit_map_p,
-                                                      literals_num,
-                                                      &header.bytecode_size,
-                                                      &header.idx_to_lit_map_size);
+  bool is_ok = bc_save_bytecode_data (buffer_p,
+                                      buffer_size,
+                                      &buffer_write_offset,
+                                      bytecode_data_p,
+                                      lit_map_p,
+                                      literals_num,
+                                      &header.scopes_num);
+
+  JERRY_ASSERT (header.scopes_num != 0);
 
   if (lit_map_p != NULL)
   {
@@ -1782,12 +1788,12 @@ jerry_exec_snapshot (const void *snapshot_p, /**< snapshot */
   }
 
   const jerry_snapshot_header_t *header_p = (const jerry_snapshot_header_t *) (snapshot_data_p + snapshot_read);
-  if (snapshot_read + sizeof (jerry_snapshot_header_t) > snapshot_size)
+  if (snapshot_read + JERRY_ALIGNUP (sizeof (jerry_snapshot_header_t), MEM_ALIGNMENT) > snapshot_size)
   {
     return JERRY_COMPLETION_CODE_INVALID_SNAPSHOT_FORMAT;
   }
 
-  snapshot_read += sizeof (jerry_snapshot_header_t);
+  snapshot_read += JERRY_ALIGNUP (sizeof (jerry_snapshot_header_t), MEM_ALIGNMENT);
 
   if (snapshot_read + header_p->lit_table_size > snapshot_size)
   {
@@ -1809,19 +1815,19 @@ jerry_exec_snapshot (const void *snapshot_p, /**< snapshot */
 
   snapshot_read += header_p->lit_table_size;
 
-  if (snapshot_read + header_p->bytecode_size + header_p->idx_to_lit_map_size > snapshot_size)
+  if (snapshot_read > snapshot_size)
   {
     mem_heap_free_block (lit_map_p);
     return JERRY_COMPLETION_CODE_INVALID_SNAPSHOT_FORMAT;
   }
 
   const bytecode_data_header_t *bytecode_data_p;
-  bytecode_data_p = serializer_load_bytecode_with_idx_map (snapshot_data_p + snapshot_read,
-                                                           header_p->bytecode_size,
-                                                           header_p->idx_to_lit_map_size,
-                                                           lit_map_p,
-                                                           literals_num,
-                                                           is_copy);
+  bytecode_data_p = bc_load_bytecode_data (snapshot_data_p + snapshot_read,
+                                           snapshot_size - snapshot_read,
+                                           lit_map_p,
+                                           literals_num,
+                                           is_copy,
+                                           header_p->scopes_num);
 
   if (lit_map_p != NULL)
   {

jerry-core/lit/lit-literal-storage.cpp

@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 
+#include "bytecode-data.h"
 #include "ecma-helpers.h"
 #include "jrt.h"
 #include "lit-literal-storage.h"
@@ -666,26 +667,16 @@ lit_dump_literals_for_snapshot (uint8_t *buffer_p, /**< output snapshot buffer *
     }
   }
 
-  uint32_t aligned_size = JERRY_ALIGNUP (lit_table_size, MEM_ALIGNMENT);
-
-  if (aligned_size != lit_table_size)
+  if (!bc_align_data_in_output_buffer (&lit_table_size,
+                                       buffer_p,
+                                       buffer_size,
+                                       in_out_buffer_offset_p))
   {
-    JERRY_ASSERT (aligned_size > lit_table_size);
-
-    uint8_t padding = 0;
-    uint32_t padding_bytes_num = (uint32_t) (aligned_size - lit_table_size);
-
-    for (uint32_t i = 0; i < padding_bytes_num; i++)
-    {
-      if (!jrt_write_to_buffer_by_offset (buffer_p, buffer_size, in_out_buffer_offset_p, padding))
-      {
-        return false;
-      }
-    }
+    return false;
   }
 
   *out_map_num_p = literals_num;
-  *out_lit_table_size_p = aligned_size;
+  *out_lit_table_size_p = lit_table_size;
 
   return true;
 } /* lit_dump_literals_for_snapshot */