Fix constantness of 'jerry_merge_snapshots' function. (#2504)

LaszloLango · robertsipka · commit 8547380d46ef · 2018-09-03T14:00:07.000+02:00
'jerry_merge_snapshots' should not modify the input snapshots. Updated the
related unit test. Also fixed some minor style issues.

JerryScript-DCO-1.0-Signed-off-by: László Langó llango.u-szeged@partner.samsung.com
diff --git a/jerry-core/api/jerry-snapshot.c b/jerry-core/api/jerry-snapshot.c
@@ -965,7 +965,7 @@ jerry_snapshot_result (const uint32_t *snapshot_p, /**< snapshot */
   }
   else
   {
-    const uint8_t *literal_base_p = (uint8_t *) (snapshot_data_p + header_p->lit_table_offset);
+    const uint8_t *literal_base_p = snapshot_data_p + header_p->lit_table_offset;
 
     bytecode_p = snapshot_load_compiled_code ((const uint8_t *) bytecode_p,
                                               literal_base_p,
@@ -1055,13 +1055,13 @@ scan_snapshot_functions (const uint8_t *buffer_p, /**< snapshot buffer start */
 
   do
   {
-    ecma_compiled_code_t *bytecode_p = (ecma_compiled_code_t *) buffer_p;
+    const ecma_compiled_code_t *bytecode_p = (ecma_compiled_code_t *) buffer_p;
     uint32_t code_size = ((uint32_t) bytecode_p->size) << JMEM_ALIGNMENT_LOG;
 
     if ((bytecode_p->status_flags & CBC_CODE_FLAGS_FUNCTION)
         && !(bytecode_p->status_flags & CBC_CODE_FLAGS_STATIC_FUNCTION))
     {
-      ecma_value_t *literal_start_p;
+      const ecma_value_t *literal_start_p;
       uint32_t argument_end;
       uint32_t const_literal_end;
 
@@ -1087,7 +1087,6 @@ scan_snapshot_functions (const uint8_t *buffer_p, /**< snapshot buffer start */
         if ((literal_start_p[i] & ECMA_VALUE_TYPE_MASK) == ECMA_TYPE_SNAPSHOT_OFFSET)
         {
           ecma_value_t lit_value = ecma_snapshot_get_literal (literal_base_p, literal_start_p[i]);
-          literal_start_p[i] = lit_value;
           ecma_save_literals_append_value (lit_value, lit_pool_p);
         }
       }
@@ -1103,7 +1102,6 @@ scan_snapshot_functions (const uint8_t *buffer_p, /**< snapshot buffer start */
           if ((literal_start_p[i] & ECMA_VALUE_TYPE_MASK) == ECMA_TYPE_SNAPSHOT_OFFSET)
           {
             ecma_value_t lit_value = ecma_snapshot_get_literal (literal_base_p, literal_start_p[i]);
-            literal_start_p[i] = lit_value;
             ecma_save_literals_append_value (lit_value, lit_pool_p);
           }
         }
@@ -1119,15 +1117,16 @@ scan_snapshot_functions (const uint8_t *buffer_p, /**< snapshot buffer start */
  * Update all literal offsets in a snapshot data.
  */
 static void
-update_literal_offsets (uint8_t *buffer_p, /**< snapshot buffer start */
+update_literal_offsets (uint8_t *buffer_p, /**< [in,out] snapshot buffer start */
                         const uint8_t *buffer_end_p, /**< snapshot buffer end */
-                        lit_mem_to_snapshot_id_map_entry_t *lit_map_p) /**< literal map */
+                        const lit_mem_to_snapshot_id_map_entry_t *lit_map_p, /**< literal map */
+                        const uint8_t *literal_base_p) /**< start of literal data */
 {
   JERRY_ASSERT (buffer_end_p > buffer_p);
 
   do
   {
-    ecma_compiled_code_t *bytecode_p = (ecma_compiled_code_t *) buffer_p;
+    const ecma_compiled_code_t *bytecode_p = (ecma_compiled_code_t *) buffer_p;
     uint32_t code_size = ((uint32_t) bytecode_p->size) << JMEM_ALIGNMENT_LOG;
 
     if ((bytecode_p->status_flags & CBC_CODE_FLAGS_FUNCTION)
@@ -1156,12 +1155,12 @@ update_literal_offsets (uint8_t *buffer_p, /**< snapshot buffer start */
 
       for (uint32_t i = 0; i < const_literal_end; i++)
       {
-        if (ecma_is_value_string (literal_start_p[i])
-            || ecma_is_value_float_number (literal_start_p[i]))
+        if ((literal_start_p[i] & ECMA_VALUE_TYPE_MASK) == ECMA_TYPE_SNAPSHOT_OFFSET)
         {
-          lit_mem_to_snapshot_id_map_entry_t *current_p = lit_map_p;
+          ecma_value_t lit_value = ecma_snapshot_get_literal (literal_base_p, literal_start_p[i]);
+          const lit_mem_to_snapshot_id_map_entry_t *current_p = lit_map_p;
 
-          while (current_p->literal_id != literal_start_p[i])
+          while (current_p->literal_id != lit_value)
           {
             current_p++;
           }
@@ -1178,11 +1177,12 @@ update_literal_offsets (uint8_t *buffer_p, /**< snapshot buffer start */
 
         for (uint32_t i = 0; i < argument_end; i++)
         {
-          if (literal_start_p[i] != ECMA_VALUE_EMPTY)
+          if ((literal_start_p[i] & ECMA_VALUE_TYPE_MASK) == ECMA_TYPE_SNAPSHOT_OFFSET)
           {
-            lit_mem_to_snapshot_id_map_entry_t *current_p = lit_map_p;
+            ecma_value_t lit_value = ecma_snapshot_get_literal (literal_base_p, literal_start_p[i]);
+            const lit_mem_to_snapshot_id_map_entry_t *current_p = lit_map_p;
 
-            while (current_p->literal_id != literal_start_p[i])
+            while (current_p->literal_id != lit_value)
             {
               current_p++;
             }
@@ -1251,7 +1251,7 @@ jerry_merge_snapshots (const uint32_t **inp_buffers_p, /**< array of (pointers t
 
     uint32_t start_offset = header_p->func_offsets[0];
     const uint8_t *data_p = (const uint8_t *) inp_buffers_p[i];
-    const uint8_t *literal_base_p = (uint8_t *) (data_p + header_p->lit_table_offset);
+    const uint8_t *literal_base_p = data_p + header_p->lit_table_offset;
 
     JERRY_ASSERT (header_p->number_of_funcs > 0);
 
@@ -1311,9 +1311,11 @@ jerry_merge_snapshots (const uint32_t **inp_buffers_p, /**< array of (pointers t
             ((const uint8_t *) inp_buffers_p[i]) + start_offset,
             current_header_p->lit_table_offset - start_offset);
 
+    const uint8_t *literal_base_p = ((const uint8_t *) inp_buffers_p[i]) + current_header_p->lit_table_offset;
     update_literal_offsets (dst_p,
                             dst_p + current_header_p->lit_table_offset - start_offset,
-                            lit_map_p);
+                            lit_map_p,
+                            literal_base_p);
 
     uint32_t current_offset = (uint32_t) (dst_p - (uint8_t *) out_buffer_p) - start_offset;
 
diff --git a/jerry-core/ecma/base/ecma-literal-storage.c b/jerry-core/ecma/base/ecma-literal-storage.c
@@ -346,7 +346,7 @@ ecma_save_literals_add_compiled_code (const ecma_compiled_code_t *compiled_code_
  * Save literals to specified snapshot buffer.
  *
  * Note:
- *   Frees lit_pool_p regardless of success.
+ *      Frees 'lit_pool_p' regardless of success.
  *
  * @return true - if save was performed successfully (i.e. buffer size is sufficient),
  *         false - otherwise
diff --git a/tests/unit-core/test-snapshot.c b/tests/unit-core/test-snapshot.c
@@ -286,7 +286,7 @@ main (void)
     size_t snapshot_sizes[2];
     static uint32_t merged_snapshot_buffer[SNAPSHOT_BUFFER_SIZE];
 
-    const char *code_to_snapshot_p = "123";
+    const char *code_to_snapshot_p = "var a = 'hello'; 123";
 
     jerry_init (JERRY_INIT_EMPTY);
     jerry_value_t generate_result;
@@ -305,7 +305,7 @@ main (void)
 
     jerry_cleanup ();
 
-    code_to_snapshot_p = "456";
+    code_to_snapshot_p = "var b = 'hello'; 456";
 
     jerry_init (JERRY_INIT_EMPTY);
     generate_result = jerry_generate_snapshot (NULL,
@@ -331,6 +331,12 @@ main (void)
     snapshot_buffers[0] = snapshot_buffer_0;
     snapshot_buffers[1] = snapshot_buffer_1;
 
+    static uint32_t snapshot_buffer_0_bck[SNAPSHOT_BUFFER_SIZE];
+    static uint32_t snapshot_buffer_1_bck[SNAPSHOT_BUFFER_SIZE];
+
+    memcpy (snapshot_buffer_0_bck, snapshot_buffer_0, SNAPSHOT_BUFFER_SIZE);
+    memcpy (snapshot_buffer_1_bck, snapshot_buffer_1, SNAPSHOT_BUFFER_SIZE);
+
     size_t merged_size = jerry_merge_snapshots (snapshot_buffers,
                                                 snapshot_sizes,
                                                 2,
@@ -340,6 +346,8 @@ main (void)
 
     jerry_cleanup ();
 
+    TEST_ASSERT (0 == memcmp (snapshot_buffer_0_bck, snapshot_buffer_0, SNAPSHOT_BUFFER_SIZE));
+    TEST_ASSERT (0 == memcmp (snapshot_buffer_1_bck, snapshot_buffer_1, SNAPSHOT_BUFFER_SIZE));
 
     jerry_init (JERRY_INIT_EMPTY);
 

Original file line number	Diff line number	Diff line change
`@@ -965,7 +965,7 @@ jerry_snapshot_result (const uint32_t snapshot_p, /< snapshot /`
`965`	`965`	`}`
`966`	`966`	`else`
`967`	`967`	`{`
`968`		`- const uint8_t literal_base_p = (uint8_t ) (snapshot_data_p + header_p->lit_table_offset);`
	`968`	`+ const uint8_t *literal_base_p = snapshot_data_p + header_p->lit_table_offset;`
`969`	`969`
`970`	`970`	`bytecode_p = snapshot_load_compiled_code ((const uint8_t *) bytecode_p,`
`971`	`971`	`literal_base_p,`
`@@ -1055,13 +1055,13 @@ scan_snapshot_functions (const uint8_t buffer_p, /< snapshot buffer start /`
`1055`	`1055`
`1056`	`1056`	`do`
`1057`	`1057`	`{`
`1058`		`- ecma_compiled_code_t bytecode_p = (ecma_compiled_code_t ) buffer_p;`
	`1058`	`+ const ecma_compiled_code_t bytecode_p = (ecma_compiled_code_t ) buffer_p;`
`1059`	`1059`	`uint32_t code_size = ((uint32_t) bytecode_p->size) << JMEM_ALIGNMENT_LOG;`
`1060`	`1060`
`1061`	`1061`	`if ((bytecode_p->status_flags & CBC_CODE_FLAGS_FUNCTION)`
`1062`	`1062`	`&& !(bytecode_p->status_flags & CBC_CODE_FLAGS_STATIC_FUNCTION))`
`1063`	`1063`	`{`
`1064`		`- ecma_value_t *literal_start_p;`
	`1064`	`+ const ecma_value_t *literal_start_p;`
`1065`	`1065`	`uint32_t argument_end;`
`1066`	`1066`	`uint32_t const_literal_end;`
`1067`	`1067`
`@@ -1087,7 +1087,6 @@ scan_snapshot_functions (const uint8_t buffer_p, /< snapshot buffer start /`
`1087`	`1087`	`if ((literal_start_p[i] & ECMA_VALUE_TYPE_MASK) == ECMA_TYPE_SNAPSHOT_OFFSET)`
`1088`	`1088`	`{`
`1089`	`1089`	`ecma_value_t lit_value = ecma_snapshot_get_literal (literal_base_p, literal_start_p[i]);`
`1090`		`- literal_start_p[i] = lit_value;`
`1091`	`1090`	`ecma_save_literals_append_value (lit_value, lit_pool_p);`
`1092`	`1091`	`}`
`1093`	`1092`	`}`
`@@ -1103,7 +1102,6 @@ scan_snapshot_functions (const uint8_t buffer_p, /< snapshot buffer start /`
`1103`	`1102`	`if ((literal_start_p[i] & ECMA_VALUE_TYPE_MASK) == ECMA_TYPE_SNAPSHOT_OFFSET)`
`1104`	`1103`	`{`
`1105`	`1104`	`ecma_value_t lit_value = ecma_snapshot_get_literal (literal_base_p, literal_start_p[i]);`
`1106`		`- literal_start_p[i] = lit_value;`
`1107`	`1105`	`ecma_save_literals_append_value (lit_value, lit_pool_p);`
`1108`	`1106`	`}`
`1109`	`1107`	`}`
`@@ -1119,15 +1117,16 @@ scan_snapshot_functions (const uint8_t buffer_p, /< snapshot buffer start /`
`1119`	`1117`	`* Update all literal offsets in a snapshot data.`
`1120`	`1118`	`*/`
`1121`	`1119`	`static void`
`1122`		`-update_literal_offsets (uint8_t buffer_p, /< snapshot buffer start /`
	`1120`	`+update_literal_offsets (uint8_t buffer_p, /< [in,out] snapshot buffer start /`
`1123`	`1121`	`const uint8_t buffer_end_p, /< snapshot buffer end /`
`1124`		`- lit_mem_to_snapshot_id_map_entry_t lit_map_p) /< literal map /`
	`1122`	`+ const lit_mem_to_snapshot_id_map_entry_t lit_map_p, /< literal map /`
	`1123`	`+ const uint8_t literal_base_p) /< start of literal data /`
`1125`	`1124`	`{`
`1126`	`1125`	`JERRY_ASSERT (buffer_end_p > buffer_p);`
`1127`	`1126`
`1128`	`1127`	`do`
`1129`	`1128`	`{`
`1130`		`- ecma_compiled_code_t bytecode_p = (ecma_compiled_code_t ) buffer_p;`
	`1129`	`+ const ecma_compiled_code_t bytecode_p = (ecma_compiled_code_t ) buffer_p;`
`1131`	`1130`	`uint32_t code_size = ((uint32_t) bytecode_p->size) << JMEM_ALIGNMENT_LOG;`
`1132`	`1131`
`1133`	`1132`	`if ((bytecode_p->status_flags & CBC_CODE_FLAGS_FUNCTION)`
`@@ -1156,12 +1155,12 @@ update_literal_offsets (uint8_t buffer_p, /< snapshot buffer start /`
`1156`	`1155`
`1157`	`1156`	`for (uint32_t i = 0; i < const_literal_end; i++)`
`1158`	`1157`	`{`
`1159`		`- if (ecma_is_value_string (literal_start_p[i])`
`1160`		`- \|\| ecma_is_value_float_number (literal_start_p[i]))`
	`1158`	`+ if ((literal_start_p[i] & ECMA_VALUE_TYPE_MASK) == ECMA_TYPE_SNAPSHOT_OFFSET)`
`1161`	`1159`	`{`
`1162`		`- lit_mem_to_snapshot_id_map_entry_t *current_p = lit_map_p;`
	`1160`	`+ ecma_value_t lit_value = ecma_snapshot_get_literal (literal_base_p, literal_start_p[i]);`
	`1161`	`+ const lit_mem_to_snapshot_id_map_entry_t *current_p = lit_map_p;`
`1163`	`1162`
`1164`		`- while (current_p->literal_id != literal_start_p[i])`
	`1163`	`+ while (current_p->literal_id != lit_value)`
`1165`	`1164`	`{`
`1166`	`1165`	`current_p++;`
`1167`	`1166`	`}`
`@@ -1178,11 +1177,12 @@ update_literal_offsets (uint8_t buffer_p, /< snapshot buffer start /`
`1178`	`1177`
`1179`	`1178`	`for (uint32_t i = 0; i < argument_end; i++)`
`1180`	`1179`	`{`
`1181`		`- if (literal_start_p[i] != ECMA_VALUE_EMPTY)`
	`1180`	`+ if ((literal_start_p[i] & ECMA_VALUE_TYPE_MASK) == ECMA_TYPE_SNAPSHOT_OFFSET)`
`1182`	`1181`	`{`
`1183`		`- lit_mem_to_snapshot_id_map_entry_t *current_p = lit_map_p;`
	`1182`	`+ ecma_value_t lit_value = ecma_snapshot_get_literal (literal_base_p, literal_start_p[i]);`
	`1183`	`+ const lit_mem_to_snapshot_id_map_entry_t *current_p = lit_map_p;`
`1184`	`1184`
`1185`		`- while (current_p->literal_id != literal_start_p[i])`
	`1185`	`+ while (current_p->literal_id != lit_value)`
`1186`	`1186`	`{`
`1187`	`1187`	`current_p++;`
`1188`	`1188`	`}`
`@@ -1251,7 +1251,7 @@ jerry_merge_snapshots (const uint32_t inp_buffers_p, /< array of (pointers t`
`1251`	`1251`
`1252`	`1252`	`uint32_t start_offset = header_p->func_offsets[0];`
`1253`	`1253`	`const uint8_t data_p = (const uint8_t ) inp_buffers_p[i];`
`1254`		`- const uint8_t literal_base_p = (uint8_t ) (data_p + header_p->lit_table_offset);`
	`1254`	`+ const uint8_t *literal_base_p = data_p + header_p->lit_table_offset;`
`1255`	`1255`
`1256`	`1256`	`JERRY_ASSERT (header_p->number_of_funcs > 0);`
`1257`	`1257`
`@@ -1311,9 +1311,11 @@ jerry_merge_snapshots (const uint32_t inp_buffers_p, /< array of (pointers t`
`1311`	`1311`	`((const uint8_t *) inp_buffers_p[i]) + start_offset,`
`1312`	`1312`	`current_header_p->lit_table_offset - start_offset);`
`1313`	`1313`
	`1314`	`+ const uint8_t literal_base_p = ((const uint8_t ) inp_buffers_p[i]) + current_header_p->lit_table_offset;`
`1314`	`1315`	`update_literal_offsets (dst_p,`
`1315`	`1316`	`dst_p + current_header_p->lit_table_offset - start_offset,`
`1316`		`- lit_map_p);`
	`1317`	`+ lit_map_p,`
	`1318`	`+ literal_base_p);`
`1317`	`1319`
`1318`	`1320`	`uint32_t current_offset = (uint32_t) (dst_p - (uint8_t *) out_buffer_p) - start_offset;`
`1319`	`1321`
Original file line number	Diff line number	Diff line change
`@@ -346,7 +346,7 @@ ecma_save_literals_add_compiled_code (const ecma_compiled_code_t *compiled_code_`
`346`	`346`	`* Save literals to specified snapshot buffer.`
`347`	`347`	`*`
`348`	`348`	`* Note:`
`349`		`- * Frees lit_pool_p regardless of success.`
	`349`	`+ * Frees 'lit_pool_p' regardless of success.`
`350`	`350`	`*`
`351`	`351`	`* @return true - if save was performed successfully (i.e. buffer size is sufficient),`
`352`	`352`	`* false - otherwise`