Storing literals' indexes instead of literals' contents in ecma-strings if possible.

src/libcoreint/interpreter.c

@@ -192,6 +192,8 @@ try_get_string_by_idx (T_IDX idx, /**< literal id */
 
   FIXME (ecma_char_t strncpy);
 
+  JERRY_ASSERT (buffer_p != NULL);
+
   __strncpy ((char*)buffer_p, (const char*)str_p, (size_t)req_length);
 
   return req_length;

src/libcoreint/opcodes.c

@@ -137,20 +137,28 @@ free_string_literal_copy (string_literal_copy *str_lit_descr_p) /**< string lite
 static bool
 do_strict_eval_arguments_check (ecma_reference_t ref) /**< ECMA-reference */
 {
-  ecma_string_t* magic_string_eval = ecma_get_magic_string (ECMA_MAGIC_STRING_EVAL);
+  bool ret;
-  ecma_string_t* magic_string_arguments = ecma_get_magic_string (ECMA_MAGIC_STRING_ARGUMENTS);
 
-  bool ret = (ref.is_strict
+  if (ref.is_strict
-              && (ecma_compare_ecma_string_to_ecma_string (ref.referenced_name_p,
+      && (ref.base.value_type == ECMA_TYPE_OBJECT)
-                                                           magic_string_eval) == 0
+      && (ECMA_GET_POINTER (ref.base.value) != NULL)
-                  || ecma_compare_ecma_string_to_ecma_string (ref.referenced_name_p,
+      && (((ecma_object_t*) ECMA_GET_POINTER (ref.base.value))->is_lexical_environment))
-                                                              magic_string_arguments) == 0)
+  {
-              && (ref.base.value_type == ECMA_TYPE_OBJECT)
+    ecma_string_t* magic_string_eval = ecma_get_magic_string (ECMA_MAGIC_STRING_EVAL);
-              && (ECMA_GET_POINTER (ref.base.value) != NULL)
+    ecma_string_t* magic_string_arguments = ecma_get_magic_string (ECMA_MAGIC_STRING_ARGUMENTS);
-              && (((ecma_object_t*) ECMA_GET_POINTER (ref.base.value))->is_lexical_environment));
 
-  ecma_deref_ecma_string (magic_string_eval);
+    ret = (ecma_compare_ecma_string_to_ecma_string (ref.referenced_name_p,
-  ecma_deref_ecma_string (magic_string_arguments);
+                                                    magic_string_eval) == 0
+           || ecma_compare_ecma_string_to_ecma_string (ref.referenced_name_p,
+                                                       magic_string_arguments) == 0);
+
+    ecma_deref_ecma_string (magic_string_eval);
+    ecma_deref_ecma_string (magic_string_arguments);
+  }
+  else
+  {
+    ret = false;
+  }
 
   return ret;
 } /* do_strict_eval_arguments_check */
@@ -182,12 +190,9 @@ get_variable_value (struct __int_data *int_data, /**< interpreter context */
   }
   else
   {
-    string_literal_copy var_name;
     ecma_reference_t ref;
 
-    init_string_literal_copy (var_idx, &var_name);
+    ecma_string_t *var_name_string_p = ecma_new_ecma_string_from_lit_index (var_idx);
-    ecma_string_t *var_name_string_p = ecma_new_ecma_string (var_name.str_p);
-    free_string_literal_copy (&var_name);
 
     ref = ecma_op_get_identifier_reference (int_data->lex_env_p,
                                             var_name_string_p,
@@ -239,12 +244,9 @@ set_variable_value (struct __int_data *int_data, /**< interpreter context */
   }
   else
   {
-    string_literal_copy var_name;
     ecma_reference_t ref;
 
-    init_string_literal_copy (var_idx, &var_name);
+    ecma_string_t *var_name_string_p = ecma_new_ecma_string_from_lit_index (var_idx);
-    ecma_string_t *var_name_string_p = ecma_new_ecma_string (var_name.str_p);
-    free_string_literal_copy (&var_name);
 
     ref = ecma_op_get_identifier_reference (int_data->lex_env_p,
                                             var_name_string_p,
@@ -779,12 +781,7 @@ opfunc_assignment (OPCODE opdata, /**< operation data */
     }
     case OPCODE_ARG_TYPE_STRING:
     {
-      string_literal_copy str_value;
+      ecma_string_t *ecma_string_p = ecma_new_ecma_string_from_lit_index (src_val_descr);
-      ecma_string_t *ecma_string_p;
-
-      init_string_literal_copy (src_val_descr, &str_value);
-      ecma_string_p = ecma_new_ecma_string (str_value.str_p);
-      free_string_literal_copy (&str_value);
 
       get_value_completion = ecma_make_completion_value (ECMA_COMPLETION_TYPE_NORMAL,
                                                          ecma_make_string_value (ecma_string_p),
@@ -1706,10 +1703,7 @@ ecma_completion_value_t
 opfunc_var_decl (OPCODE opdata, /**< operation data */
                  struct __int_data *int_data) /**< interpreter context */
 {
-  string_literal_copy variable_name;
+  ecma_string_t *var_name_string_p = ecma_new_ecma_string_from_lit_index (opdata.data.var_decl.variable_name);
-  init_string_literal_copy (opdata.data.var_decl.variable_name, &variable_name);
-  ecma_string_t *var_name_string_p = ecma_new_ecma_string (variable_name.str_p);
-  free_string_literal_copy (&variable_name);
 
   if (ecma_is_completion_value_normal_false (ecma_op_has_binding (int_data->lex_env_p,
                                                                   var_name_string_p)))
@@ -1762,10 +1756,7 @@ function_declaration (struct __int_data *int_data, /**< interpreter context */
 
   const opcode_counter_t function_code_opcode_idx = (opcode_counter_t) (jmp_down_opcode_idx + 1);
 
-  string_literal_copy function_name;
+  ecma_string_t *function_name_string_p = ecma_new_ecma_string_from_lit_index (function_name_lit_idx);
-  init_string_literal_copy (function_name_lit_idx, &function_name);
-  ecma_string_t *function_name_string_p = ecma_new_ecma_string (function_name.str_p);
-  free_string_literal_copy (&function_name);
 
   ecma_completion_value_t ret_value = ecma_op_function_declaration (int_data->lex_env_p,
                                                                     function_name_string_p,
@@ -1809,10 +1800,7 @@ opfunc_func_decl_1 (OPCODE opdata, /**< operation data */
 {
   int_data->pos++;
 
-  string_literal_copy argument_name;
+  ecma_string_t *arg_name_string_p = ecma_new_ecma_string_from_lit_index (opdata.data.func_decl_1.arg1_lit_idx);
-  init_string_literal_copy (opdata.data.func_decl_1.arg1_lit_idx, &argument_name);
-  ecma_string_t *arg_name_string_p = ecma_new_ecma_string (argument_name.str_p);
-  free_string_literal_copy (&argument_name);
   
   ecma_completion_value_t ret_value = function_declaration (int_data,
                                                             opdata.data.func_decl_1.name_lit_idx,
@@ -1836,16 +1824,11 @@ opfunc_func_decl_2 (OPCODE opdata, /**< operation data */
 {
   int_data->pos++;
 
-  string_literal_copy argument1_name, argument2_name;
-  init_string_literal_copy (opdata.data.func_decl_2.arg1_lit_idx, &argument1_name);
-  init_string_literal_copy (opdata.data.func_decl_2.arg2_lit_idx, &argument2_name);
   ecma_string_t* arg_names_strings[2] =
   {
-    ecma_new_ecma_string (argument1_name.str_p),
+    ecma_new_ecma_string_from_lit_index (opdata.data.func_decl_2.arg1_lit_idx),
-    ecma_new_ecma_string (argument2_name.str_p)
+    ecma_new_ecma_string_from_lit_index (opdata.data.func_decl_2.arg2_lit_idx)
   };
-  free_string_literal_copy (&argument2_name);
-  free_string_literal_copy (&argument1_name);
   
   ecma_completion_value_t ret_value = function_declaration (int_data,
                                                             opdata.data.func_decl_1.name_lit_idx,

src/libecmaobjects/ecma-helpers-string.c

@@ -26,6 +26,8 @@
 #include "globals.h"
 #include "jerry-libc.h"
 
+#include "interpreter.h"
+
 /**
  * Allocate new ecma-string and fill it with characters from specified buffer
  *
@@ -112,6 +114,32 @@ ecma_new_ecma_string_from_number (ecma_number_t num) /**< ecma-number */
   return string_desc_p;
 } /* ecma_new_ecma_string_from_number */
 
+/**
+ * Allocate new ecma-string and fill it with reference string literal
+ *
+ * @return pointer to ecma-string descriptor
+ */
+ecma_string_t*
+ecma_new_ecma_string_from_lit_index (literal_index_t lit_index) /**< ecma-number */
+{
+  ecma_string_t* string_desc_p = ecma_alloc_string ();
+  string_desc_p->refs = 1;
+
+  FIXME (/* Interface for getting literal's length */);
+  TODO (/* Lazy calculate literal's length */);
+
+  ssize_t size_required = try_get_string_by_idx ((uint8_t) lit_index, NULL, 0);
+  JERRY_ASSERT (size_required < 0);
+
+  string_desc_p->length = (ecma_length_t) ((size_t)-size_required / sizeof (ecma_char_t) - 1);
+  string_desc_p->is_length_valid = true;
+  string_desc_p->container = ECMA_STRING_CONTAINER_LIT_TABLE;
+
+  string_desc_p->u.lit_index = lit_index;
+
+  return string_desc_p;
+} /* ecma_new_ecma_string_from_lit_index */
+
 /**
  * Increase reference counter of ecma-string.
  *
@@ -256,6 +284,8 @@ ecma_string_to_zt_string (const ecma_string_t *string_desc_p, /**< ecma-string d
   JERRY_ASSERT (buffer_p != NULL);
   JERRY_ASSERT (buffer_size > 0);
 
+  JERRY_ASSERT (string_desc_p->is_length_valid);
+
   const ecma_length_t string_length = string_desc_p->length;
   size_t required_buffer_size = sizeof (ecma_char_t) * string_length + 1 /* for zero char */;
 
@@ -325,17 +355,32 @@ ecma_compare_ecma_string_to_ecma_string (const ecma_string_t *string1_p, /* ecma
     return true;
   }
 
+  if (string1_p->container == ECMA_STRING_CONTAINER_LIT_TABLE
+      && string2_p->container == ECMA_STRING_CONTAINER_LIT_TABLE)
+  {
+    return (string1_p->u.lit_index == string2_p->u.lit_index);
+  }
+
   if (string1_p->container == ECMA_STRING_CONTAINER_HEAP_NUMBER
       || string2_p->container == ECMA_STRING_CONTAINER_HEAP_NUMBER)
   {
     JERRY_UNIMPLEMENTED ();
   }
 
+  JERRY_ASSERT (string1_p->is_length_valid);
+  JERRY_ASSERT (string2_p->is_length_valid);
+
   if (string1_p->length != string2_p->length)
   {
     return false;
   }
 
+  if (string1_p->container == ECMA_STRING_CONTAINER_LIT_TABLE
+           || string2_p->container == ECMA_STRING_CONTAINER_LIT_TABLE)
+  {
+    JERRY_UNIMPLEMENTED ();
+  }
+
   ecma_length_t chars_left = string1_p->length;
 
   if (string1_p->container == ECMA_STRING_CONTAINER_IN_DESCRIPTOR
@@ -344,17 +389,6 @@ ecma_compare_ecma_string_to_ecma_string (const ecma_string_t *string1_p, /* ecma
     return (__memcmp (string1_p->u.chars, string2_p->u.chars, chars_left * sizeof (ecma_char_t)) == 0);
   }
 
-  if (string1_p->container == ECMA_STRING_CONTAINER_LIT_TABLE
-      && string2_p->container == ECMA_STRING_CONTAINER_LIT_TABLE)
-  {
-    return (string1_p->u.lit_index == string2_p->u.lit_index);
-  }
-  else if (string1_p->container == ECMA_STRING_CONTAINER_LIT_TABLE
-           || string2_p->container == ECMA_STRING_CONTAINER_LIT_TABLE)
-  {
-    JERRY_UNIMPLEMENTED ();
-  }
-
   if (string1_p->container == ECMA_STRING_CONTAINER_HEAP_CHUNKS
       && string2_p->container == ECMA_STRING_CONTAINER_IN_DESCRIPTOR)
   {

src/libecmaobjects/ecma-helpers.h

@@ -88,6 +88,7 @@ extern bool ecma_is_empty_completion_value (ecma_completion_value_t value);
 /* ecma-helpers-string.c */
 extern ecma_string_t* ecma_new_ecma_string (const ecma_char_t *string_p);
 extern ecma_string_t* ecma_new_ecma_string_from_number (ecma_number_t number);
+extern ecma_string_t* ecma_new_ecma_string_from_lit_index (literal_index_t lit_index);
 extern void ecma_ref_ecma_string (ecma_string_t *string_desc_p);
 extern void ecma_deref_ecma_string (ecma_string_t *string_p);
 extern ecma_length_t ecma_get_ecma_string_length (ecma_string_t *string_desc_p);