YourWishes/jerryscript
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor literal-storage to not use C++ features

Browse Source 
JerryScript-DCO-1.0-Signed-off-by: Roland Takacs rtakacs.u-szeged@partner.samsung.com
This commit is contained in:
Roland Takacs
2015-12-24 17:24:46 +03:00
committed by Peter Gal
parent f932b7d48c
commit 21f561f8ef
36 changed files with 2603 additions and 3134 deletions
Download Patch File Download Diff File Expand all files Collapse all files
jerry-core/lit/lit-globals.h
+16
View File
@@ -17,6 +17,7 @@
#define LIT_GLOBALS_H
#include "jrt.h"
#include "rcs-cpointer.h"
/**
* ECMAScript standard defines terms "code unit" and "character" as 16-bit unsigned value
@@ -123,6 +124,21 @@ typedef uint32_t lit_code_point_t;
*/
typedef uint8_t lit_string_hash_t;
/**
* Literal type
*/
typedef rcs_record_t *lit_literal_t;
/**
* Compressed pointer type
*/
typedef rcs_cpointer_t lit_cpointer_t;
/**
* Invalid literal
*/
#define NOT_A_LITERAL (rcs_cpointer_null_cp ())
/**
* ECMA string hash value length, in bits
*/
jerry-core/lit/lit-literal-storage.cpp
+84 -744
View File
@@ -1,4 +1,5 @@
/* Copyright 2015 Samsung Electronics Co., Ltd.
* Copyright 2015 University of Szeged
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -13,336 +14,86 @@
* limitations under the License.
*/
#include "bytecode-data.h"
#include "ecma-helpers.h"
#include "jrt.h"
#include "lit-literal-storage.h"
#include "lit-literal.h"
#include "lit-magic-strings.h"
/**
* Literal storage
* As our libc library doesn't call constructors of static variables, lit_storage is initialized
* in lit_init function by placement new operator.
*/
lit_literal_storage_t lit_storage;
#include "ecma-helpers.h"
#include "rcs-allocator.h"
#include "rcs-iterator.h"
#include "rcs-records.h"
/**
* Get pointer to the previous record inside the literal storage
*
* @return pointer to the previous record of NULL if this is the first record ('prev' field in the header)
*/
rcs_record_t *
lit_charset_record_t::get_prev () const
{
rcs_record_iterator_t it ((rcs_recordset_t *)&lit_storage, (rcs_record_t *)this);
it.skip (RCS_DYN_STORAGE_LENGTH_UNIT);
cpointer_t cpointer;
cpointer.packed_value = it.read<uint16_t> ();
return cpointer_t::decompress (cpointer);
} /* lit_charset_record_t::get_prev */
/**
* Set the pointer to the previous record inside the literal storage (sets 'prev' field in the header)
*/
void
lit_charset_record_t::set_prev (rcs_record_t *prev_rec_p) /**< pointer to the record to set as previous */
{
rcs_record_iterator_t it ((rcs_recordset_t *)&lit_storage, (rcs_record_t *)this);
it.skip (RCS_DYN_STORAGE_LENGTH_UNIT);
it.write<uint16_t> (cpointer_t::compress (prev_rec_p).packed_value);
} /* lit_charset_record_t::set_prev */
/**
* Set the charset of the record
*/
void
lit_charset_record_t::set_charset (const lit_utf8_byte_t *str, /**< buffer containing characters to set */
lit_utf8_size_t size) /**< size of the buffer in bytes */
{
JERRY_ASSERT (header_size () + size == get_size () - get_alignment_bytes_count ());
rcs_record_iterator_t it ((rcs_recordset_t *)&lit_storage, (rcs_record_t *)this);
it.skip (header_size ());
for (lit_utf8_size_t i = 0; i < get_length (); ++i)
{
it.write<lit_utf8_byte_t> (str[i]);
it.skip<lit_utf8_byte_t> ();
}
} /* lit_charset_record_t::set_charset */
/**
* Get the characters which are stored to the record
*
* @return number of code units written to the buffer
*/
lit_utf8_size_t
lit_charset_record_t::get_charset (lit_utf8_byte_t *buff, /**< output buffer */
size_t size) /**< size of the output buffer in bytes */
{
JERRY_ASSERT (buff && size >= sizeof (lit_utf8_byte_t));
rcs_record_iterator_t it ((rcs_recordset_t *)&lit_storage, (rcs_record_t *)this);
it.skip (header_size ());
lit_utf8_size_t len = get_length ();
lit_utf8_size_t i;
for (i = 0; i < len && size > 0; ++i)
{
buff[i] = it.read<lit_utf8_byte_t> ();
it.skip<lit_utf8_byte_t> ();
size -= sizeof (lit_utf8_byte_t);
}
return i;
} /* lit_charset_record_t::get_charset */
/**
* Compares characters from the record to the string
*
* @return 0 if strings are equal
* -1 if str_to_compare_with is greater
* 1 if str_to_compare_with is less
*/
int
lit_charset_record_t::compare_utf8 (const lit_utf8_byte_t *str_to_compare_with, /**< buffer with string to compare */
lit_utf8_size_t str_size) /**< size of the string */
{
TODO ("Support utf-8 in comparison.");
size_t i;
if (get_length () == 0)
{
if (str_to_compare_with != NULL)
{
return -1;
}
else
{
return 0;
}
}
if (str_to_compare_with == NULL)
{
return 1;
}
rcs_record_iterator_t it_this (&lit_storage, this);
it_this.skip (header_size ());
for (i = 0; i < get_length () && i < str_size; i++)
{
lit_utf8_byte_t chr = it_this.read<lit_utf8_byte_t> ();
if (chr > str_to_compare_with[i])
{
return 1;
}
else if (chr < str_to_compare_with[i])
{
return -1;
}
it_this.skip<lit_utf8_byte_t> ();
}
if (i < str_size)
{
return -1;
}
return 0;
} /* lit_charset_record_t::compare_zt */
/**
* Compares two lit_charset_record_t records for equality
*
* @return true if strings inside records are equal
* false otherwise
*/
bool
lit_charset_record_t::is_equal (lit_charset_record_t *rec) /**< charset record to compare with */
{
if (get_length () != rec->get_length ())
{
return false;
}
rcs_record_iterator_t it_this (&lit_storage, this);
rcs_record_iterator_t it_record (&lit_storage, rec);
it_this.skip (header_size ());
it_record.skip (rec->header_size ());
for (lit_utf8_size_t i = 0; i < get_length (); i++)
{
if (it_this.read<lit_utf8_byte_t> () != it_record.read<lit_utf8_byte_t> ())
{
return false;
}
it_this.skip<lit_utf8_byte_t> ();
it_record.skip<lit_utf8_byte_t> ();
}
return true;
} /* lit_charset_record_t::is_equal */
/**
* Compare this lit_charset_record_t record with string (which could contain '\0' characters) for equality
*
* @return true if compared instances are equal
* false otherwise
*/
bool
lit_charset_record_t::is_equal_utf8_string (const lit_utf8_byte_t *str, /**< string to compare with */
lit_utf8_size_t str_size) /**< length of the string */
{
rcs_record_iterator_t it_this (&lit_storage, this);
it_this.skip (header_size ());
for (lit_utf8_size_t i = 0; i < get_length () && i < str_size; i++)
{
if (it_this.read<lit_utf8_byte_t> () != str[i])
{
return false;
}
it_this.skip<lit_utf8_byte_t> ();
}
return get_length () == str_size;
} /* lit_charset_record_t::equal_non_zt */
/**
* Dump charset record to specified snapshot buffer
*
* @return number of bytes dumped,
* or 0 - upon dump failure
*/
uint32_t
lit_charset_record_t::dump_for_snapshot (uint8_t *buffer_p, /**< buffer to dump to */
size_t buffer_size, /**< buffer size */
size_t *in_out_buffer_offset_p) /**< in-out: buffer write offset */
{
lit_utf8_size_t length = get_length ();
if (!jrt_write_to_buffer_by_offset (buffer_p, buffer_size, in_out_buffer_offset_p, length))
{
return 0;
}
rcs_record_iterator_t it_this (&lit_storage, this);
it_this.skip (header_size ());
for (lit_utf8_size_t i = 0; i < length; i++)
{
lit_utf8_byte_t next_byte = it_this.read<lit_utf8_byte_t> ();
it_this.skip<lit_utf8_byte_t> ();
if (!jrt_write_to_buffer_by_offset (buffer_p, buffer_size, in_out_buffer_offset_p, next_byte))
{
return 0;
}
}
return ((uint32_t) sizeof (length) + length * (uint32_t) sizeof (lit_utf8_byte_t));
} /* lit_charset_record_t::dump_for_snapshot */
/**
* Dump number record to specified snapshot buffer
*
* @return number of bytes dumped,
* or 0 - upon dump failure
*/
uint32_t
lit_number_record_t::dump_for_snapshot (uint8_t *buffer_p, /**< buffer to dump to */
size_t buffer_size, /**< buffer size */
size_t *in_out_buffer_offset_p) const /**< in-out: buffer write offset */
{
/* dumping as double (not ecma_number_t), because ecma_number_t can be float or double,
* depending on engine compile-time configuration */
double num = get_number ();
if (!jrt_write_to_buffer_by_offset (buffer_p, buffer_size, in_out_buffer_offset_p, num))
{
return 0;
}
return ((uint32_t) sizeof (num));
} /* lit_number_record_t::dump_for_snapshot */
rcs_record_set_t rcs_lit_storage;
/**
* Create charset record in the literal storage
*
* @return pointer to the created record
* @return pointer to the created record
*/
lit_charset_record_t *
lit_literal_storage_t::create_charset_record (const lit_utf8_byte_t *str, /**< string to be placed in the record */
lit_utf8_size_t buf_size) /**< size in bytes of the buffer which holds the
* string */
rcs_record_t *
lit_create_charset_literal (rcs_record_set_t *rec_set_p, /**< recordset */
const lit_utf8_byte_t *str_p, /**< string to be placed into the record */
const lit_utf8_size_t buf_size) /**< size in bytes of the buffer which holds the string */
{
const size_t alignment = lit_charset_record_t::size (buf_size) - (lit_charset_record_t::header_size () + buf_size);
const size_t record_size = RCS_CHARSET_HEADER_SIZE + buf_size;
const size_t aligned_record_size = JERRY_ALIGNUP (record_size, RCS_DYN_STORAGE_LENGTH_UNIT);
const size_t alignment = aligned_record_size - record_size;
lit_charset_record_t *ret = alloc_record<lit_charset_record_t, size_t> (LIT_STR, buf_size);
rcs_record_t *rec_p = rcs_alloc_record (rec_set_p, RCS_RECORD_TYPE_CHARSET, aligned_record_size);
ret->set_alignment_bytes_count (alignment);
ret->set_charset (str, buf_size);
ret->set_hash (lit_utf8_string_calc_hash (str, ret->get_length ()));
rcs_record_set_alignment_bytes_count (rec_p, (uint8_t) alignment);
rcs_record_set_charset (rec_set_p, rec_p, str_p, buf_size);
rcs_record_set_hash (rec_p, lit_utf8_string_calc_hash (str_p, rcs_record_get_length (rec_p)));
return ret;
} /* lit_literal_storage_t::create_charset_record */
return rec_p;
} /* lit_create_charset_literal */
/**
* Create magic string record in the literal storage
* Create magic string record in the literal storage.
*
* @return pointer to the created record
*/
lit_magic_record_t *
lit_literal_storage_t::create_magic_record (lit_magic_string_id_t id) /**< id of a magic string */
rcs_record_t *
lit_create_magic_literal (rcs_record_set_t *rec_set_p, /**< recordset */
lit_magic_string_id_t id) /**< id of magic string */
{
lit_magic_record_t *ret = alloc_record<lit_magic_record_t> (LIT_MAGIC_STR);
ret->set_magic_str_id (id);
rcs_record_t *rec_p = rcs_alloc_record (rec_set_p, RCS_RECORD_TYPE_MAGIC_STR, RCS_MAGIC_STR_HEADER_SIZE);
rcs_record_set_magic_str_id (rec_p, id);
return ret;
} /* lit_literal_storage_t::create_magic_record */
return rec_p;
} /* lit_create_magic_literal */
/**
* Create external magic string record in the literal storage
* Create external magic string record in the literal storage.
*
* @return pointer to the created record
*/
lit_magic_record_t *
lit_literal_storage_t::create_magic_record_ex (lit_magic_string_ex_id_t id) /**< id of a magic string */
rcs_record_t *
lit_create_magic_literal_ex (rcs_record_set_t *rec_set_p, /**< recordset */
lit_magic_string_ex_id_t id) /**< id of magic string */
{
lit_magic_record_t *ret = alloc_record<lit_magic_record_t> (LIT_MAGIC_STR_EX);
ret->set_magic_str_id (id);
rcs_record_t *rec_p = rcs_alloc_record (rec_set_p, RCS_RECORD_TYPE_MAGIC_STR_EX, RCS_MAGIC_STR_HEADER_SIZE);
rcs_record_set_magic_str_ex_id (rec_p, id);
return ret;
} /* lit_literal_storage_t::create_magic_record_ex */
return rec_p;
} /* lit_create_magic_record_ex */
/**
* Create number record in the literal storage
* Create number record in the literal storage.
*
* @return pointer to the created record
*/
lit_number_record_t *
lit_literal_storage_t::create_number_record (ecma_number_t num) /**< number */
rcs_record_t *
lit_create_number_literal (rcs_record_set_t *rec_set_p, /** recordset */
ecma_number_t num) /**< numeric value */
{
lit_number_record_t *ret = alloc_record<lit_number_record_t> (LIT_NUMBER);
rcs_record_iterator_t it_this (this, ret);
const size_t record_size = RCS_NUMBER_HEADER_SIZE + sizeof (ecma_number_t);
rcs_record_t *rec_p = rcs_alloc_record (rec_set_p, RCS_RECORD_TYPE_NUMBER, record_size);
it_this.skip (ret->header_size ());
it_this.write<ecma_number_t> (num);
rcs_iterator_t it_ctx = rcs_iterator_create (rec_set_p, rec_p);
rcs_iterator_skip (&it_ctx, RCS_NUMBER_HEADER_SIZE);
rcs_iterator_write (&it_ctx, &num, sizeof (ecma_number_t));
return ret;
} /* lit_literal_storage_t::create_number_record */
return rec_p;
} /* lit_create_number_literal */
/**
* Count literal records in the storage
@@ -350,77 +101,87 @@ lit_literal_storage_t::create_number_record (ecma_number_t num) /**< number */
* @return number of literals
*/
uint32_t
lit_literal_storage_t::count_literals (void)
lit_count_literals (rcs_record_set_t *rec_set_p) /**< recordset */
{
uint32_t num = 0;
rcs_record_t *rec_p;
for (literal_t lit = lit_storage.get_first (); lit != NULL; lit = lit_storage.get_next (lit))
for (rec_p = rcs_record_get_first (rec_set_p);
rec_p != NULL;
rec_p = rcs_record_get_next (rec_set_p, rec_p))
{
rcs_record_t::type_t type = lit->get_type ();
if (type >= _first_type_id)
if (rcs_record_get_type (rec_p) >= RCS_RECORD_TYPE_FIRST)
{
num++;
}
}
return num;
} /* lit_literal_storage_t::count_literals */
} /* lit_count_literals */
/**
* Dump the contents of the literal storage
* Dump the contents of the literal storage.
*/
void
lit_literal_storage_t::dump ()
lit_dump_literals (rcs_record_set_t *rec_set_p) /**< recordset */
{
rcs_record_t *rec_p;
printf ("LITERALS:\n");
for (rcs_record_t *rec_p = lit_storage.get_first (); rec_p != NULL; rec_p = lit_storage.get_next (rec_p))
for (rec_p = rcs_record_get_first (rec_set_p);
rec_p != NULL;
rec_p = rcs_record_get_next (rec_set_p, rec_p))
{
printf ("%p ", rec_p);
printf ("[%3zu] ", get_record_size (rec_p));
printf ("[%3zu] ", rcs_record_get_size (rec_p));
switch (rec_p->get_type ())
switch (rcs_record_get_type (rec_p))
{
case LIT_STR:
case RCS_RECORD_TYPE_CHARSET:
{
lit_charset_record_t *lit_p = static_cast<lit_charset_record_t *> (rec_p);
rcs_record_iterator_t it_this (this, rec_p);
rcs_iterator_t it_ctx = rcs_iterator_create (rec_set_p, rec_p);
rcs_iterator_skip (&it_ctx, RCS_CHARSET_HEADER_SIZE);
it_this.skip (lit_charset_record_t::header_size ());
size_t str_len = rcs_record_get_length (rec_p);
size_t i;
for (size_t i = 0; i < lit_p->get_length (); ++i)
for (i = 0; i < str_len; ++i)
{
FIXME ("Support proper printing of characters which occupy more than one byte.")
printf ("%c", it_this.read<lit_utf8_byte_t> ());
it_this.skip<lit_utf8_byte_t> ();
lit_utf8_byte_t chr;
rcs_iterator_read (&it_ctx, &chr, sizeof (lit_utf8_byte_t));
rcs_iterator_skip (&it_ctx, sizeof (lit_utf8_byte_t));
printf ("%c", chr);
}
printf (" : STRING");
break;
}
case LIT_MAGIC_STR:
case RCS_RECORD_TYPE_MAGIC_STR:
{
lit_magic_string_id_t id = lit_magic_record_get_magic_str_id (rec_p);
lit_magic_string_id_t id = rcs_record_get_magic_str_id (rec_p);
printf ("%s : MAGIC STRING", lit_get_magic_string_utf8 (id));
printf (" [id=%d] ", id);
break;
}
case LIT_MAGIC_STR_EX:
case RCS_RECORD_TYPE_MAGIC_STR_EX:
{
lit_magic_string_ex_id_t id = lit_magic_record_ex_get_magic_str_id (rec_p);
lit_magic_string_ex_id_t id = rcs_record_get_magic_str_ex_id (rec_p);
printf ("%s : EXT MAGIC STRING", lit_get_magic_string_ex_utf8 (id));
printf (" [id=%d] ", id);
break;
}
case LIT_NUMBER:
case RCS_RECORD_TYPE_NUMBER:
{
lit_number_record_t *lit_p = static_cast<lit_number_record_t *> (rec_p);
ecma_number_t value = rcs_record_get_number (rec_set_p, rec_p);
if (ecma_number_is_nan (lit_p->get_number ()))
if (ecma_number_is_nan (value))
{
printf ("%s : NUMBER", "NaN");
}
@@ -429,7 +190,7 @@ lit_literal_storage_t::dump ()
lit_utf8_byte_t buff[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER + 1u];
memset (buff, 0, sizeof (buff));
lit_utf8_size_t sz = ecma_number_to_utf8_string (lit_p->get_number (), buff, sizeof (buff));
lit_utf8_size_t sz = ecma_number_to_utf8_string (value, buff, sizeof (buff));
JERRY_ASSERT (sz <= ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER);
printf ("%s : NUMBER", buff);
@@ -445,425 +206,4 @@ lit_literal_storage_t::dump ()
printf ("\n");
}
} /* lit_literal_storage_t::dump */
/**
* Get previous record in the literal storage
*
* @return pointer to the previous record relative to rec_p, or NULL if rec_p is the first record in the storage
*/
rcs_record_t *
lit_literal_storage_t::get_prev (rcs_record_t *rec_p) /**< record, relative to which previous should be found */
{
switch (rec_p->get_type ())
{
case LIT_STR:
{
return (static_cast<lit_charset_record_t *> (rec_p))->get_prev ();
}
case LIT_MAGIC_STR:
case LIT_MAGIC_STR_EX:
{
return (static_cast<lit_magic_record_t *> (rec_p))->get_prev ();
}
case LIT_NUMBER:
{
return (static_cast<lit_number_record_t *> (rec_p))->get_prev ();
}
default:
{
JERRY_ASSERT (rec_p->get_type () < _first_type_id);
return rcs_recordset_t::get_prev (rec_p);
}
}
} /* lit_literal_storage_t::get_prev */
/**
* Set pointer to the previous record
*/
void
lit_literal_storage_t::set_prev (rcs_record_t *rec_p, /**< record to modify */
rcs_record_t *prev_rec_p) /**< record which should be set as previous */
{
switch (rec_p->get_type ())
{
case LIT_STR:
{
return (static_cast<lit_charset_record_t *> (rec_p))->set_prev (prev_rec_p);
}
case LIT_MAGIC_STR:
case LIT_MAGIC_STR_EX:
{
return (static_cast<lit_magic_record_t *> (rec_p))->set_prev (prev_rec_p);
}
case LIT_NUMBER:
{
return (static_cast<lit_number_record_t *> (rec_p))->set_prev (prev_rec_p);
}
default:
{
JERRY_ASSERT (rec_p->get_type () < _first_type_id);
return rcs_recordset_t::set_prev (rec_p, prev_rec_p);
}
}
} /* lit_literal_storage_t::set_prev */
/**
* Get size of a record
*
* @return size of a record in bytes
*/
size_t
lit_literal_storage_t::get_record_size (rcs_record_t* rec_p) /**< pointer to a record */
{
switch (rec_p->get_type ())
{
case LIT_STR:
{
return (static_cast<lit_charset_record_t *> (rec_p))->get_size ();
}
case LIT_MAGIC_STR:
case LIT_MAGIC_STR_EX:
{
return lit_magic_record_t::size ();
}
case LIT_NUMBER:
{
return lit_number_record_t::size ();
}
default:
{
JERRY_ASSERT (rec_p->get_type () < _first_type_id);
return rcs_recordset_t::get_record_size (rec_p);
}
}
} /* lit_literal_storage_t::get_record_size */
#ifdef JERRY_ENABLE_SNAPSHOT
/**
* Dump literals to specified snapshot buffer
*
* @return true, if dump was performed successfully (i.e. buffer size is sufficient),
* false - otherwise.
*/
bool
lit_dump_literals_for_snapshot (uint8_t *buffer_p, /**< output snapshot buffer */
size_t buffer_size, /**< size of the buffer */
size_t *in_out_buffer_offset_p, /**< in-out: write position in the buffer */
lit_mem_to_snapshot_id_map_entry_t **out_map_p, /**< out: map from literal identifiers
* to the literal offsets
* in snapshot */
uint32_t *out_map_num_p, /**< out: number of literals */
uint32_t *out_lit_table_size_p) /**< out: number of bytes, dumped to snapshot buffer */
{
uint32_t literals_num = lit_storage.count_literals ();
uint32_t lit_table_size = 0;
*out_map_p = NULL;
*out_map_num_p = 0;
*out_lit_table_size_p = 0;
if (!jrt_write_to_buffer_by_offset (buffer_p, buffer_size, in_out_buffer_offset_p, literals_num))
{
return false;
}
lit_table_size += (uint32_t) sizeof (literals_num);
if (literals_num != 0)
{
bool is_ok = true;
size_t id_map_size = sizeof (lit_mem_to_snapshot_id_map_entry_t) * literals_num;
lit_mem_to_snapshot_id_map_entry_t *id_map_p;
id_map_p = (lit_mem_to_snapshot_id_map_entry_t *) mem_heap_alloc_block (id_map_size, MEM_HEAP_ALLOC_SHORT_TERM);
uint32_t literal_index = 0;
for (literal_t lit = lit_storage.get_first ();
lit != NULL;
lit = lit_storage.get_next (lit))
{
rcs_record_t::type_t type = lit->get_type ();
if (!(type >= lit_literal_storage_t::LIT_TYPE_FIRST
&& type <= lit_literal_storage_t::LIT_TYPE_LAST))
{
continue;
}
if (!jrt_write_to_buffer_by_offset (buffer_p, buffer_size, in_out_buffer_offset_p, type))
{
is_ok = false;
break;
}
uint32_t sz;
if (type == LIT_STR_T)
{
lit_charset_record_t *rec_p = static_cast<lit_charset_record_t *> (lit);
sz = rec_p->dump_for_snapshot (buffer_p, buffer_size, in_out_buffer_offset_p);
}
else if (type == LIT_MAGIC_STR_T
|| type == LIT_MAGIC_STR_EX_T)
{
lit_magic_record_t *rec_p = static_cast<lit_magic_record_t *> (lit);
if (type == LIT_MAGIC_STR_T)
{
sz = rec_p->dump_for_snapshot<lit_magic_string_id_t> (buffer_p, buffer_size, in_out_buffer_offset_p);
}
else
{
JERRY_ASSERT (type == LIT_MAGIC_STR_EX_T);
sz = rec_p->dump_for_snapshot<lit_magic_string_ex_id_t> (buffer_p, buffer_size, in_out_buffer_offset_p);
}
}
else
{
JERRY_ASSERT (type == LIT_NUMBER_T);
lit_number_record_t *rec_p = static_cast<lit_number_record_t *> (lit);
sz = rec_p->dump_for_snapshot (buffer_p, buffer_size, in_out_buffer_offset_p);
}
if (sz == 0)
{
/* write failed */
is_ok = false;
break;
}
else
{
lit_cpointer_t lit_cp = lit_cpointer_t::compress (lit);
id_map_p[literal_index].literal_id = lit_cp;
id_map_p[literal_index].literal_offset = lit_table_size;
lit_table_size += (uint32_t) sizeof (type);
lit_table_size += sz;
}
literal_index++;
}
if (!is_ok)
{
mem_heap_free_block (id_map_p);
return false;
}
else
{
JERRY_ASSERT (literal_index == literals_num);
*out_map_p = id_map_p;
}
}
if (!bc_align_data_in_output_buffer (&lit_table_size,
buffer_p,
buffer_size,
in_out_buffer_offset_p))
{
return false;
}
*out_map_num_p = literals_num;
*out_lit_table_size_p = lit_table_size;
return true;
} /* lit_dump_literals_for_snapshot */
/**
* Load literals from snapshot
*
* @return true, if load was performed successfully (i.e. literals dump in the snapshot is consistent),
* false - otherwise (i.e. snapshot is incorrect).
*/
bool
lit_load_literals_from_snapshot (const uint8_t *lit_table_p, /**< buffer with literal table in snapshot */
uint32_t lit_table_size, /**< size of literal table in snapshot */
lit_mem_to_snapshot_id_map_entry_t **out_map_p, /**< out: map from literal offsets
* in snapshot to identifiers
* of loaded literals in literal
* storage */
uint32_t *out_map_num_p, /**< out: literals number */
bool is_copy) /** flag, indicating whether the passed in-snapshot data
* should be copied to engine's memory (true),
* or it can be referenced until engine is stopped
* (i.e. until call to jerry_cleanup) */
{
/* currently, always performing literals copy */
(void) is_copy;
*out_map_p = NULL;
*out_map_num_p = 0;
size_t lit_table_read = 0;
uint32_t literals_num;
if (!jrt_read_from_buffer_by_offset (lit_table_p,
lit_table_size,
&lit_table_read,
&literals_num))
{
return false;
}
if (literals_num == 0)
{
return true;
}
size_t id_map_size = sizeof (lit_mem_to_snapshot_id_map_entry_t) * literals_num;
lit_mem_to_snapshot_id_map_entry_t *id_map_p;
id_map_p = (lit_mem_to_snapshot_id_map_entry_t *) mem_heap_alloc_block (id_map_size, MEM_HEAP_ALLOC_SHORT_TERM);
bool is_ok = true;
for (uint32_t lit_index = 0; lit_index < literals_num; lit_index++)
{
uint32_t offset = (uint32_t) lit_table_read;
JERRY_ASSERT (offset == lit_table_read);
rcs_record_t::type_t type;
if (!jrt_read_from_buffer_by_offset (lit_table_p,
lit_table_size,
&lit_table_read,
&type))
{
is_ok = false;
break;
}
literal_t lit;
if (type == LIT_STR_T)
{
lit_utf8_size_t length;
if (!jrt_read_from_buffer_by_offset (lit_table_p,
lit_table_size,
&lit_table_read,
&length)
|| (lit_table_read + length > lit_table_size))
{
is_ok = false;
break;
}
lit = lit_find_or_create_literal_from_utf8_string (lit_table_p + lit_table_read, length);
lit_table_read += length;
}
else if (type == LIT_MAGIC_STR_T)
{
lit_magic_string_id_t id;
if (!jrt_read_from_buffer_by_offset (lit_table_p,
lit_table_size,
&lit_table_read,
&id))
{
is_ok = false;
break;
}
const lit_utf8_byte_t *magic_str_p = lit_get_magic_string_utf8 (id);
lit_utf8_size_t magic_str_sz = lit_get_magic_string_size (id);
/*
* TODO:
* Consider searching literal storage by magic string identifier instead of by its value
*/
lit = lit_find_or_create_literal_from_utf8_string (magic_str_p, magic_str_sz);
}
else if (type == LIT_MAGIC_STR_EX_T)
{
lit_magic_string_ex_id_t id;
if (!jrt_read_from_buffer_by_offset (lit_table_p,
lit_table_size,
&lit_table_read,
&id))
{
is_ok = false;
break;
}
const lit_utf8_byte_t *magic_str_ex_p = lit_get_magic_string_ex_utf8 (id);
lit_utf8_size_t magic_str_ex_sz = lit_get_magic_string_ex_size (id);
/*
* TODO:
* Consider searching literal storage by magic string identifier instead of by its value
*/
lit = lit_find_or_create_literal_from_utf8_string (magic_str_ex_p, magic_str_ex_sz);
}
else if (type == LIT_NUMBER_T)
{
double num;
if (!jrt_read_from_buffer_by_offset (lit_table_p,
lit_table_size,
&lit_table_read,
&num))
{
is_ok = false;
break;
}
lit = lit_find_or_create_literal_from_num ((ecma_number_t) num);
}
else
{
is_ok = false;
break;
}
id_map_p[lit_index].literal_offset = offset;
id_map_p[lit_index].literal_id = lit_cpointer_t::compress (lit);
}
if (is_ok)
{
*out_map_p = id_map_p;
*out_map_num_p = literals_num;
return true;
}
else
{
mem_heap_free_block (id_map_p);
return false;
}
} /* lit_load_literals_from_snapshot */
#endif /* JERRY_ENABLE_SNAPSHOT */
template void rcs_record_iterator_t::skip<uint8_t> ();
template void rcs_record_iterator_t::skip<uint16_t> ();
template void rcs_record_iterator_t::skip<uint32_t> ();
template void rcs_record_iterator_t::write<uint8_t> (uint8_t);
template uint8_t rcs_record_iterator_t::read<uint8_t> ();
template void rcs_record_iterator_t::write<ecma_number_t> (ecma_number_t);
template ecma_number_t rcs_record_iterator_t::read<ecma_number_t> ();
template void rcs_record_iterator_t::write<uint16_t> (uint16_t);
template uint16_t rcs_record_iterator_t::read<uint16_t> ();
template lit_magic_string_id_t lit_magic_record_t::get_magic_str_id<lit_magic_string_id_t>() const;
template lit_magic_string_ex_id_t lit_magic_record_t::get_magic_str_id<lit_magic_string_ex_id_t>() const;
template void lit_magic_record_t::set_magic_str_id<lit_magic_string_id_t>(lit_magic_string_id_t);
template void lit_magic_record_t::set_magic_str_id<lit_magic_string_ex_id_t>(lit_magic_string_ex_id_t);
template uint32_t lit_magic_record_t::dump_for_snapshot<lit_magic_string_id_t>(uint8_t *, size_t, size_t *) const;
template uint32_t lit_magic_record_t::dump_for_snapshot<lit_magic_string_ex_id_t>(uint8_t *, size_t, size_t *) const;
template lit_charset_record_t *rcs_recordset_t::alloc_record<lit_charset_record_t> (rcs_record_t::type_t type,
size_t size);
template lit_magic_record_t *rcs_recordset_t::alloc_record<lit_magic_record_t> (rcs_record_t::type_t type);
template lit_number_record_t *rcs_recordset_t::alloc_record<lit_number_record_t> (rcs_record_t::type_t type);
} /* lit_dump_literals */
jerry-core/lit/lit-literal-storage.h
+9 -459
View File
@@ -1,4 +1,5 @@
/* Copyright 2015 Samsung Electronics Co., Ltd.
* Copyright 2015 University of Szeged
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -17,466 +18,15 @@
#define LIT_LITERAL_STORAGE_H
#include "ecma-globals.h"
#include "rcs-recordset.h"
class lit_literal_storage_t;
extern lit_literal_storage_t lit_storage;
extern rcs_record_set_t rcs_lit_storage;
/**
* Charset record
*
* layout:
* ------- header -----------------------
* type (4 bits)
* alignment (2 bits)
* unused (2 bits)
* hash (8 bits)
* length (16 bits)
* pointer to prev (16 bits)
* ------- characters -------------------
* ...
* chars
* ....
* ------- alignment bytes --------------
* unused bytes (their count is specified
* by 'alignment' field in header)
* --------------------------------------
*/
class lit_charset_record_t : public rcs_record_t
{
friend class rcs_recordset_t;
friend class lit_literal_storage_t;
extern rcs_record_t *lit_create_charset_literal (rcs_record_set_t *, const lit_utf8_byte_t *, lit_utf8_size_t);
extern rcs_record_t *lit_create_magic_literal (rcs_record_set_t *, lit_magic_string_id_t);
extern rcs_record_t *lit_create_magic_literal_ex (rcs_record_set_t *, lit_magic_string_ex_id_t);
extern rcs_record_t *lit_create_number_literal (rcs_record_set_t *, ecma_number_t);
public:
/**
* Calculate the size that record will occupy inside the storage
*
* @return size of the record in bytes
*/
static size_t
size (size_t size) /**< size of the charset buffer */
{
return JERRY_ALIGNUP (size + header_size (), RCS_DYN_STORAGE_LENGTH_UNIT);
} /* size */
extern uint32_t lit_count_literals (rcs_record_set_t *);
extern void lit_dump_literals (rcs_record_set_t *);
/**
* Get the size of the header part of the record
*
* @return size of the header in bytes
*/
static size_t
header_size ()
{
return _header_size;
} /* header_size */
/**
* Get the count of the alignment bytes at the end of record.
* These bytes are needed to align the record to RCS_DYN_STORAGE_ALIGNMENT.
*
* @return alignment bytes count (the value of the 'alignment' field in the header)
*/
size_t
get_alignment_bytes_count () const
{
return get_field (_alignment_field_pos, _alignment_field_width);
} /* get_alignment_bytes_count */
/**
* Set the count of the alignment bytes at the end of record (the value of the 'alignment' field in the header)
*/
void
set_alignment_bytes_count (size_t count) /**< count of the alignment bytes */
{
JERRY_ASSERT (count <= RCS_DYN_STORAGE_LENGTH_UNIT);
set_field (_alignment_field_pos, _alignment_field_width, count);
} /* set_alignment_bytes_count */
/**
* Get hash value of the record's charset.
*
* @return hash value of the string (the value of the 'hash' field in the header)
*/
lit_string_hash_t
get_hash () const
{
return (lit_string_hash_t) get_field (_hash_field_pos, _hash_field_width);
} /* get_hash */
/**
* Get the length of the string, which is contained inside the record
*
* @return length of the string (bytes count)
*/
lit_utf8_size_t
get_length () const
{
return (lit_utf8_size_t) (get_size () - header_size () - get_alignment_bytes_count ());
} /* get_length */
/**
* Get the size of the record
*
* @return size of the record in bytes
*/
size_t
get_size () const
{
return get_field (_length_field_pos, _length_field_width) * RCS_DYN_STORAGE_LENGTH_UNIT;
} /* get_size */
rcs_record_t *get_prev () const;
lit_utf8_size_t get_charset (lit_utf8_byte_t *, size_t);
int compare_utf8 (const lit_utf8_byte_t *, lit_utf8_size_t);
bool is_equal (lit_charset_record_t *);
bool is_equal_utf8_string (const lit_utf8_byte_t *, lit_utf8_size_t);
uint32_t dump_for_snapshot (uint8_t *, size_t, size_t *);
private:
/**
* Set record's size (the value of the 'length' field in the header)
*/
void
set_size (size_t size) /**< size in bytes */
{
JERRY_ASSERT (JERRY_ALIGNUP (size, RCS_DYN_STORAGE_LENGTH_UNIT) == size);
set_field (_length_field_pos, _length_field_width, size >> RCS_DYN_STORAGE_LENGTH_UNIT_LOG);
} /* set_size */
/**
* Set record's hash (the value of the 'hash' field in the header)
*/
void
set_hash (lit_string_hash_t hash) /**< hash value */
{
set_field (_hash_field_pos, _hash_field_width, hash);
} /* set_hash */
void set_prev (rcs_record_t *);
void set_charset (const lit_utf8_byte_t *, lit_utf8_size_t);
/**
* Offset and length of 'alignment' field, in bits
*/
static const uint32_t _alignment_field_pos = _fields_offset_begin;
static const uint32_t _alignment_field_width = RCS_DYN_STORAGE_LENGTH_UNIT_LOG;
/**
* Offset and length of 'hash' field, in bits
*/
static const uint32_t _hash_field_pos = _alignment_field_pos + _alignment_field_width;
static const uint32_t _hash_field_width = 8u;
/**
* Offset and length of 'alignment' field, in bits
*/
static const uint32_t _length_field_pos = _hash_field_pos + _hash_field_width;
static const uint32_t _length_field_width = 16u;
/**
* Offset and length of 'prev' field, in bits
*/
static const uint32_t _prev_field_pos = _length_field_pos + _length_field_width;
static const uint32_t _prev_field_width = rcs_cpointer_t::bit_field_width;
static const size_t _header_size = RCS_DYN_STORAGE_LENGTH_UNIT + RCS_DYN_STORAGE_LENGTH_UNIT / 2;
}; /* lit_charset_record_t */
/**
* Magic string record
* Doesn't hold any characters. Corresponding string is identified by its id.
*
* Layout:
* ------- header -----------------------
* type (4 bits)
* magic string id (12 bits)
* pointer to prev (16 bits)
* --------------------------------------
*/
class lit_magic_record_t : public rcs_record_t
{
friend class rcs_recordset_t;
friend class lit_literal_storage_t;
public:
/**
* Calculate the size that record will occupy inside the storage
*
* @return size of the record in bytes
*/
static size_t size ()
{
return _size;
} /* size */
/**
* Get the size of the header part of the record
*
* @return size of the header in bytes
*/
static size_t header_size ()
{
return _size;
} /* header_size */
/**
* Get the size of the record
*
* @return size of the record in bytes
*/
size_t get_size () const
{
return _size;
} /* get_size */
/**
* Get magic string id which is held by the record
*
* @return magic string id
*/
template <typename magic_string_id_t>
magic_string_id_t get_magic_str_id () const
{
uint32_t id = get_field (magic_field_pos, magic_field_width);
return (magic_string_id_t) id;
} /* get_magic_str_id */
/**
* Dump magic string record to specified snapshot buffer
*
* @return number of bytes dumped,
* or 0 - upon dump failure
*/
template <typename magic_string_id_t>
uint32_t dump_for_snapshot (uint8_t *buffer_p, /**< buffer to dump to */
size_t buffer_size, /**< buffer size */
size_t *in_out_buffer_offset_p) const /**< in-out: buffer write offset */
{
magic_string_id_t id = get_magic_str_id<magic_string_id_t> ();
if (!jrt_write_to_buffer_by_offset (buffer_p, buffer_size, in_out_buffer_offset_p, id))
{
return 0;
}
return ((uint32_t) sizeof (id));
} /* dump_for_snapshot */
private:
/**
* Set record's size (the value of the 'length' field in the header)
*/
void set_size (size_t size) /**< size in bytes */
{
JERRY_ASSERT (size == get_size ());
} /* set_size */
template <typename magic_string_id_t>
void set_magic_str_id (magic_string_id_t id)
{
set_field (magic_field_pos, magic_field_width, id);
} /* set_magic_str_id */
/**
* Get previous record in the literal storage
*
* @return pointer to the previous record relative to this record, or NULL if this is the first record in the
* storage
*/
rcs_record_t *get_prev () const
{
return get_pointer (prev_field_pos, prev_field_width);
} /* get_prev */
/**
* Set the pointer to the previous record inside the literal storage (sets 'prev' field in the header)
*/
void set_prev (rcs_record_t *prev_rec_p)
{
set_pointer (prev_field_pos, prev_field_width, prev_rec_p);
} /* set_prev */
/**
* Offset and length of 'magic string id' field, in bits
*/
static const uint32_t magic_field_pos = _fields_offset_begin;
static const uint32_t magic_field_width = 12u;
/**
* Offset and length of 'prev' field, in bits
*/
static const uint32_t prev_field_pos = magic_field_pos + magic_field_width;
static const uint32_t prev_field_width = rcs_cpointer_t::bit_field_width;
static const size_t _size = RCS_DYN_STORAGE_LENGTH_UNIT;
}; /* lit_magic_record_t */
/**
* Number record
* Doesn't hold any characters, holds a number. Numbers from source code are represented as number literals.
*
* Layout:
* ------- header -----------------------
* type (4 bits)
* padding (12 bits)
* pointer to prev (16 bits)
* --------------------------------------
* ecma_number_t
*/
class lit_number_record_t : public rcs_record_t
{
friend class rcs_recordset_t;
friend class lit_literal_storage_t;
public:
static size_t
size ()
{
return _size;
} /* size */
/**
* Get the size of the header part of the record
*
* @return size of the header in bytes
*/
static size_t
header_size ()
{
return _header_size;
} /* header_size */
/**
* Get the size of the record
*
* @return size of the record in bytes
*/
size_t
get_size () const
{
return _size;
} /* get_size */
/**
* Get previous record in the literal storage
*
* @return pointer to the previous record relative to this record, or NULL if this is the first record in the
* storage
*/
rcs_record_t *
get_prev () const
{
return get_pointer (prev_field_pos, prev_field_width);
} /* get_prev */
/**
* Set the pointer to the previous record inside the literal storage (sets 'prev' field in the header)
*/
void
set_prev (rcs_record_t *prev_rec_p)
{
set_pointer (prev_field_pos, prev_field_width, prev_rec_p);
} /* set_prev */
/**
* Get the number which is held by the record
*
* @return number
*/
ecma_number_t
get_number () const
{
rcs_record_iterator_t it ((rcs_recordset_t *)&lit_storage,
(rcs_record_t *)this);
it.skip (header_size ());
return it.read<ecma_number_t> ();
} /* get_number */
uint32_t dump_for_snapshot (uint8_t *, size_t, size_t *) const;
private:
/**
* Set record's size (the value of the 'length' field in the header)
*/
void
set_size (size_t size) /**< size in bytes */
{
JERRY_ASSERT (size == get_size ());
} /* set_size */
/**
* Offset and length of 'prev' field, in bits
*/
static const uint32_t prev_field_pos = _fields_offset_begin + 12u;
static const uint32_t prev_field_width = rcs_cpointer_t::bit_field_width;
static const size_t _header_size = RCS_DYN_STORAGE_LENGTH_UNIT;
static const size_t _size = _header_size + sizeof (ecma_number_t);
}; /* lit_number_record_t */
/**
* Literal storage
*
* Represents flexible storage for the literals. The following records could be created inside the storage:
* - charset literal (lit_charset_record_t)
* - magic string literal (lit_magic_record_t)
* - number literal (lit_number_record_t)
*/
class lit_literal_storage_t : public rcs_recordset_t
{
public:
enum
{
LIT_TYPE_FIRST = _first_type_id,
LIT_STR = LIT_TYPE_FIRST,
LIT_MAGIC_STR,
LIT_MAGIC_STR_EX,
LIT_NUMBER,
LIT_TYPE_LAST = LIT_NUMBER
};
lit_charset_record_t *create_charset_record (const lit_utf8_byte_t *, lit_utf8_size_t);
lit_magic_record_t *create_magic_record (lit_magic_string_id_t);
lit_magic_record_t *create_magic_record_ex (lit_magic_string_ex_id_t);
lit_number_record_t *create_number_record (ecma_number_t);
uint32_t count_literals (void);
void dump ();
private:
virtual rcs_record_t *get_prev (rcs_record_t *);
virtual void set_prev (rcs_record_t *, rcs_record_t *);
virtual size_t get_record_size (rcs_record_t *);
}; /* lit_literal_storage_t */
#define LIT_STR_T (lit_literal_storage_t::LIT_STR)
#define LIT_MAGIC_STR_T (lit_literal_storage_t::LIT_MAGIC_STR)
#define LIT_MAGIC_STR_EX_T (lit_literal_storage_t::LIT_MAGIC_STR_EX)
#define LIT_NUMBER_T (lit_literal_storage_t::LIT_NUMBER)
#ifdef JERRY_ENABLE_SNAPSHOT
/**
* Map from literal identifiers to the literal offsets in snapshot (or reverse)
*/
typedef struct
{
lit_cpointer_t literal_id; /**< identifier of literal in literal storage */
uint32_t literal_offset; /**< offset of the literal in snapshot */
} lit_mem_to_snapshot_id_map_entry_t;
extern bool
lit_dump_literals_for_snapshot (uint8_t *, size_t, size_t *, lit_mem_to_snapshot_id_map_entry_t **,
uint32_t *, uint32_t *);
extern bool lit_load_literals_from_snapshot (const uint8_t *, uint32_t, lit_mem_to_snapshot_id_map_entry_t **,
uint32_t *, bool);
#endif /* JERRY_ENABLE_SNAPSHOT */
#endif /* LIT_LITERAL_STORAGE_H */
#endif /* !LIT_LITERAL_STORAGE_H */
jerry-core/lit/lit-literal.cpp
+183 -158
View File
@@ -16,7 +16,10 @@
#include "lit-literal.h"
#include "ecma-helpers.h"
#include "lit-magic-strings.h"
#include "rcs-allocator.h"
#include "rcs-records.h"
#include "rcs-iterator.h"
#include "lit-literal-storage.h"
/**
* Initialize literal storage
@@ -24,8 +27,10 @@
void
lit_init ()
{
new (&lit_storage) lit_literal_storage_t ();
lit_storage.init ();
JERRY_ASSERT (rcs_get_node_data_space_size () % RCS_DYN_STORAGE_LENGTH_UNIT == 0);
rcs_lit_storage.init ();
lit_magic_strings_init ();
lit_magic_strings_ex_init ();
} /* lit_init */
@@ -36,8 +41,8 @@ lit_init ()
void
lit_finalize ()
{
lit_storage.cleanup ();
lit_storage.finalize ();
rcs_lit_storage.cleanup ();
rcs_lit_storage.free ();
} /* lit_finalize */
/**
@@ -46,7 +51,7 @@ lit_finalize ()
void
lit_dump_literals ()
{
lit_storage.dump ();
lit_dump_literals (&rcs_lit_storage);
} /* lit_dump_literals */
/**
@@ -55,44 +60,46 @@ lit_dump_literals ()
*
* @return pointer to created record
*/
literal_t
lit_literal_t
lit_create_literal_from_utf8_string (const lit_utf8_byte_t *str_p, /**< string to initialize the record,
* could be non-zero-terminated */
lit_utf8_size_t str_size) /**< length of the string */
{
JERRY_ASSERT (str_p || !str_size);
for (lit_magic_string_id_t msi = (lit_magic_string_id_t) 0;
msi < LIT_MAGIC_STRING__COUNT;
msi = (lit_magic_string_id_t) (msi + 1))
lit_magic_string_id_t m_str_id;
for (m_str_id = (lit_magic_string_id_t) 0;
m_str_id < LIT_MAGIC_STRING__COUNT;
m_str_id = (lit_magic_string_id_t) (m_str_id + 1))
{
if (lit_get_magic_string_size (msi) != str_size)
if (lit_get_magic_string_size (m_str_id) != str_size)
{
continue;
}
if (!strncmp ((const char *) str_p, (const char *) lit_get_magic_string_utf8 (msi), str_size))
if (!strncmp ((const char *) str_p, (const char *) lit_get_magic_string_utf8 (m_str_id), str_size))
{
return lit_storage.create_magic_record (msi);
return lit_create_magic_literal (&rcs_lit_storage, m_str_id);
}
}
for (lit_magic_string_ex_id_t msi = (lit_magic_string_ex_id_t) 0;
msi < lit_get_magic_string_ex_count ();
msi = (lit_magic_string_ex_id_t) (msi + 1))
lit_magic_string_ex_id_t m_str_ex_id;
for (m_str_ex_id = (lit_magic_string_ex_id_t) 0;
m_str_ex_id < lit_get_magic_string_ex_count ();
m_str_ex_id = (lit_magic_string_ex_id_t) (m_str_ex_id + 1))
{
if (lit_get_magic_string_ex_size (msi) != str_size)
if (lit_get_magic_string_ex_size (m_str_ex_id) != str_size)
{
continue;
}
if (!strncmp ((const char *) str_p, (const char *) lit_get_magic_string_ex_utf8 (msi), str_size))
if (!strncmp ((const char *) str_p, (const char *) lit_get_magic_string_ex_utf8 (m_str_ex_id), str_size))
{
return lit_storage.create_magic_record_ex (msi);
return lit_create_magic_literal_ex (&rcs_lit_storage, m_str_ex_id);
}
}
return lit_storage.create_charset_record (str_p, str_size);
return lit_create_charset_literal (&rcs_lit_storage, str_p, str_size);
} /* lit_create_literal_from_utf8_string */
/**
@@ -101,7 +108,7 @@ lit_create_literal_from_utf8_string (const lit_utf8_byte_t *str_p, /**< string t
*
* @return pointer to a literal or NULL if no corresponding literal exists
*/
literal_t
lit_literal_t
lit_find_literal_by_utf8_string (const lit_utf8_byte_t *str_p, /**< a string to search for */
lit_utf8_size_t str_size) /**< length of the string */
{
@@ -109,30 +116,34 @@ lit_find_literal_by_utf8_string (const lit_utf8_byte_t *str_p, /**< a string to
lit_string_hash_t str_hash = lit_utf8_string_calc_hash (str_p, str_size);
for (literal_t lit = lit_storage.get_first (); lit != NULL; lit = lit_storage.get_next (lit))
lit_literal_t lit;
for (lit = rcs_record_get_first (&rcs_lit_storage);
lit != NULL;
lit = rcs_record_get_next (&rcs_lit_storage, lit))
{
rcs_record_t::type_t type = lit->get_type ();
rcs_record_type_t type = rcs_record_get_type (lit);
if (type == LIT_STR_T)
if (RCS_RECORD_TYPE_IS_CHARSET (type))
{
if (static_cast<lit_charset_record_t *>(lit)->get_hash () != str_hash)
if (rcs_record_get_hash (lit) != str_hash)
{
continue;
}
if (static_cast<lit_charset_record_t *>(lit)->get_length () != str_size)
if (rcs_record_get_length (lit) != str_size)
{
continue;
}
if (!static_cast<lit_charset_record_t *>(lit)->compare_utf8 (str_p, str_size))
if (rcs_record_is_equal_charset (&rcs_lit_storage, lit, str_p, str_size))
{
return lit;
}
}
else if (type == LIT_MAGIC_STR_T)
else if (RCS_RECORD_TYPE_IS_MAGIC_STR (type))
{
lit_magic_string_id_t magic_id = lit_magic_record_get_magic_str_id (lit);
lit_magic_string_id_t magic_id = rcs_record_get_magic_str_id (lit);
const lit_utf8_byte_t *magic_str_p = lit_get_magic_string_utf8 (magic_id);
if (lit_get_magic_string_size (magic_id) != str_size)
@@ -145,9 +156,9 @@ lit_find_literal_by_utf8_string (const lit_utf8_byte_t *str_p, /**< a string to
return lit;
}
}
else if (type == LIT_MAGIC_STR_EX_T)
else if (RCS_RECORD_TYPE_IS_MAGIC_STR_EX (type))
{
lit_magic_string_ex_id_t magic_id = lit_magic_record_ex_get_magic_str_id (lit);
lit_magic_string_ex_id_t magic_id = rcs_record_get_magic_str_ex_id (lit);
const lit_utf8_byte_t *magic_str_p = lit_get_magic_string_ex_utf8 (magic_id);
if (lit_get_magic_string_ex_size (magic_id) != str_size)
@@ -171,11 +182,11 @@ lit_find_literal_by_utf8_string (const lit_utf8_byte_t *str_p, /**< a string to
*
* @return pointer to existing or newly created record
*/
literal_t
lit_literal_t
lit_find_or_create_literal_from_utf8_string (const lit_utf8_byte_t *str_p, /**< string, could be non-zero-terminated */
lit_utf8_size_t str_size) /**< length of the string */
{
literal_t lit = lit_find_literal_by_utf8_string (str_p, str_size);
lit_literal_t lit = lit_find_literal_by_utf8_string (str_p, str_size);
if (lit == NULL)
{
@@ -191,10 +202,10 @@ lit_find_or_create_literal_from_utf8_string (const lit_utf8_byte_t *str_p, /**<
*
* @return pointer to a newly created record
*/
literal_t
lit_literal_t
lit_create_literal_from_num (ecma_number_t num) /**< number to initialize a new number literal */
{
return lit_storage.create_number_record (num);
return lit_create_number_literal (&rcs_lit_storage, num);
} /* lit_create_literal_from_num */
/**
@@ -202,10 +213,10 @@ lit_create_literal_from_num (ecma_number_t num) /**< number to initialize a new
*
* @return pointer to existing or a newly created record
*/
literal_t
lit_literal_t
lit_find_or_create_literal_from_num (ecma_number_t num) /**< number which a literal should contain */
{
literal_t lit = lit_find_literal_by_num (num);
lit_literal_t lit = lit_find_literal_by_num (num);
if (lit == NULL)
{
@@ -220,19 +231,22 @@ lit_find_or_create_literal_from_num (ecma_number_t num) /**< number which a lite
*
* @return pointer to existing or null
*/
literal_t
lit_literal_t
lit_find_literal_by_num (ecma_number_t num) /**< a number to search for */
{
for (literal_t lit = lit_storage.get_first (); lit != NULL; lit = lit_storage.get_next (lit))
lit_literal_t lit;
for (lit = rcs_record_get_first (&rcs_lit_storage);
lit != NULL;
lit = rcs_record_get_next (&rcs_lit_storage, lit))
{
rcs_record_t::type_t type = lit->get_type ();
rcs_record_type_t type = rcs_record_get_type (lit);
if (type != LIT_NUMBER_T)
if (!RCS_RECORD_TYPE_IS_NUMBER (type))
{
continue;
}
ecma_number_t lit_num = static_cast<lit_number_record_t *>(lit)->get_number ();
ecma_number_t lit_num = rcs_record_get_number (&rcs_lit_storage, lit);
if (lit_num == num)
{
@@ -250,39 +264,45 @@ lit_find_literal_by_num (ecma_number_t num) /**< a number to search for */
* false otherwise
*/
static bool
lit_literal_equal_charset_rec (literal_t lit, /**< literal to compare */
lit_charset_record_t *record) /**< charset record to compare */
lit_literal_equal_charset_rec (lit_literal_t lit, /**< literal to compare */
lit_literal_t record) /**< charset record to compare */
{
switch (lit->get_type ())
switch (rcs_record_get_type (lit))
{
case LIT_STR_T:
case RCS_RECORD_TYPE_CHARSET:
{
return static_cast<lit_charset_record_t *>(lit)->is_equal (record);
return rcs_record_is_equal (&rcs_lit_storage, lit, record);
}
case LIT_MAGIC_STR_T:
case RCS_RECORD_TYPE_MAGIC_STR:
{
lit_magic_string_id_t magic_string_id = lit_magic_record_get_magic_str_id (lit);
return record->is_equal_utf8_string (lit_get_magic_string_utf8 (magic_string_id),
lit_get_magic_string_size (magic_string_id));
lit_magic_string_id_t magic_string_id = rcs_record_get_magic_str_id (lit);
return rcs_record_is_equal_charset (&rcs_lit_storage,
record,
lit_get_magic_string_utf8 (magic_string_id),
lit_get_magic_string_size (magic_string_id));
}
case LIT_MAGIC_STR_EX_T:
case RCS_RECORD_TYPE_MAGIC_STR_EX:
{
lit_magic_string_ex_id_t magic_string_id = lit_magic_record_ex_get_magic_str_id (lit);
return record->is_equal_utf8_string (lit_get_magic_string_ex_utf8 (magic_string_id),
lit_get_magic_string_ex_size (magic_string_id));
}
case LIT_NUMBER_T:
{
lit_utf8_byte_t buff[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER];
lit_utf8_size_t copied = ecma_number_to_utf8_string (static_cast<lit_number_record_t *>(lit)->get_number (),
buff,
sizeof (buff));
lit_magic_string_ex_id_t magic_string_id = rcs_record_get_magic_str_ex_id (lit);
return record->is_equal_utf8_string (buff, copied);
return rcs_record_is_equal_charset (&rcs_lit_storage,
record,
lit_get_magic_string_ex_utf8 (magic_string_id),
lit_get_magic_string_ex_size (magic_string_id));
}
case RCS_RECORD_TYPE_NUMBER:
{
ecma_number_t num = rcs_record_get_number (&rcs_lit_storage, lit);
lit_utf8_byte_t buff[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER];
lit_utf8_size_t copied = ecma_number_to_utf8_string (num, buff, sizeof (buff));
return rcs_record_is_equal_charset (&rcs_lit_storage, record, buff, copied);
}
default:
{
JERRY_UNREACHABLE ();
return false;
}
}
} /* lit_literal_equal_charset_rec */
@@ -294,32 +314,32 @@ lit_literal_equal_charset_rec (literal_t lit, /**< literal to com
* false otherwise
*/
bool
lit_literal_equal_utf8 (literal_t lit, /**< literal to compare */
lit_literal_equal_utf8 (lit_literal_t lit, /**< literal to compare */
const lit_utf8_byte_t *str_p, /**< utf-8 string to compare */
lit_utf8_size_t str_size) /**< string size in bytes */
{
switch (lit->get_type ())
switch (rcs_record_get_type (lit))
{
case LIT_STR_T:
case RCS_RECORD_TYPE_CHARSET:
{
return static_cast<lit_charset_record_t *>(lit)->is_equal_utf8_string (str_p, str_size);
return rcs_record_is_equal_charset (&rcs_lit_storage, lit, str_p, str_size);
}
case LIT_MAGIC_STR_T:
case RCS_RECORD_TYPE_MAGIC_STR:
{
lit_magic_string_id_t magic_id = lit_magic_record_get_magic_str_id (lit);
lit_magic_string_id_t magic_id = rcs_record_get_magic_str_id (lit);
return lit_compare_utf8_string_and_magic_string (str_p, str_size, magic_id);
}
case LIT_MAGIC_STR_EX_T:
case RCS_RECORD_TYPE_MAGIC_STR_EX:
{
lit_magic_string_ex_id_t magic_id = lit_magic_record_ex_get_magic_str_id (lit);
lit_magic_string_ex_id_t magic_id = rcs_record_get_magic_str_ex_id (lit);
return lit_compare_utf8_string_and_magic_string_ex (str_p, str_size, magic_id);
}
case LIT_NUMBER_T:
case RCS_RECORD_TYPE_NUMBER:
{
ecma_number_t num = rcs_record_get_number (&rcs_lit_storage, lit);
lit_utf8_byte_t num_buf[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER];
lit_utf8_size_t num_size = ecma_number_to_utf8_string (static_cast<lit_number_record_t *>(lit)->get_number (),
num_buf,
sizeof (num_buf));
lit_utf8_size_t num_size = ecma_number_to_utf8_string (num, num_buf, sizeof (num_buf));
return lit_compare_utf8_strings (str_p, str_size, num_buf, num_size);
}
@@ -337,7 +357,7 @@ lit_literal_equal_utf8 (literal_t lit, /**< literal to compare */
* false otherwise
*/
bool
lit_literal_equal_num (literal_t lit, /**< literal to check */
lit_literal_equal_num (lit_literal_t lit, /**< literal to check */
ecma_number_t num) /**< number to compare with */
{
lit_utf8_byte_t buff[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER];
@@ -353,32 +373,35 @@ lit_literal_equal_num (literal_t lit, /**< literal to check */
* false otherwise
*/
bool
lit_literal_equal (literal_t lit1, /**< first literal */
literal_t lit2) /**< second literal */
lit_literal_equal (lit_literal_t lit1, /**< first literal */
lit_literal_t lit2) /**< second literal */
{
switch (lit2->get_type ())
switch (rcs_record_get_type (lit2))
{
case lit_literal_storage_t::LIT_STR:
case RCS_RECORD_TYPE_CHARSET:
{
return lit_literal_equal_charset_rec (lit1, static_cast<lit_charset_record_t *>(lit2));
return lit_literal_equal_charset_rec (lit1, lit2);
}
case lit_literal_storage_t::LIT_MAGIC_STR:
case RCS_RECORD_TYPE_MAGIC_STR:
{
lit_magic_string_id_t magic_str_id = lit_magic_record_get_magic_str_id (lit2);
lit_magic_string_id_t magic_str_id = rcs_record_get_magic_str_id (lit2);
return lit_literal_equal_utf8 (lit1,
lit_get_magic_string_utf8 (magic_str_id),
lit_get_magic_string_size (magic_str_id));
}
case lit_literal_storage_t::LIT_MAGIC_STR_EX:
case RCS_RECORD_TYPE_MAGIC_STR_EX:
{
lit_magic_string_ex_id_t magic_str_ex_id = lit_magic_record_ex_get_magic_str_id (lit2);
lit_magic_string_ex_id_t magic_str_ex_id = rcs_record_get_magic_str_ex_id (lit2);
return lit_literal_equal_utf8 (lit1,
lit_get_magic_string_ex_utf8 (magic_str_ex_id),
lit_get_magic_string_ex_size (magic_str_ex_id));
}
case lit_literal_storage_t::LIT_NUMBER:
case RCS_RECORD_TYPE_NUMBER:
{
return lit_literal_equal_num (lit1, static_cast<lit_number_record_t *>(lit2)->get_number ());
ecma_number_t num = rcs_record_get_number (&rcs_lit_storage, lit2);
return lit_literal_equal_num (lit1, num);
}
default:
{
@@ -395,13 +418,13 @@ lit_literal_equal (literal_t lit1, /**< first literal */
* false otherwise
*/
bool
lit_literal_equal_type_utf8 (literal_t lit, /**< literal to compare */
lit_literal_equal_type_utf8 (lit_literal_t lit, /**< literal to compare */
const lit_utf8_byte_t *str_p, /**< utf-8 string */
lit_utf8_size_t str_size) /**< string size */
{
if (lit->get_type () != LIT_STR_T
&& lit->get_type () != LIT_MAGIC_STR_T
&& lit->get_type () != LIT_MAGIC_STR_EX_T)
rcs_record_type_t type = rcs_record_get_type (lit);
if (RCS_RECORD_TYPE_IS_NUMBER (type) || RCS_RECORD_TYPE_IS_FREE (type))
{
return false;
}
@@ -417,7 +440,7 @@ lit_literal_equal_type_utf8 (literal_t lit, /**< literal to compare */
* false otherwise
*/
bool
lit_literal_equal_type_cstr (literal_t lit, /**< literal to compare */
lit_literal_equal_type_cstr (lit_literal_t lit, /**< literal to compare */
const char *c_str_p) /**< zero-terminated C-string */
{
return lit_literal_equal_type_utf8 (lit, (const lit_utf8_byte_t *) c_str_p, (lit_utf8_size_t) strlen (c_str_p));
@@ -431,10 +454,10 @@ lit_literal_equal_type_cstr (literal_t lit, /**< literal to compare */
* false otherwise
*/
bool
lit_literal_equal_type_num (literal_t lit, /**< literal to check */
lit_literal_equal_type_num (lit_literal_t lit, /**< literal to check */
ecma_number_t num) /**< number to compare with */
{
if (lit->get_type () != lit_literal_storage_t::LIT_NUMBER)
if (!RCS_RECORD_IS_NUMBER (lit))
{
return false;
}
@@ -450,10 +473,10 @@ lit_literal_equal_type_num (literal_t lit, /**< literal to check */
* false otherwise
*/
bool
lit_literal_equal_type (literal_t lit1, /**< first literal */
literal_t lit2) /**< second literal */
lit_literal_equal_type (lit_literal_t lit1, /**< first literal */
lit_literal_t lit2) /**< second literal */
{
if (lit1->get_type () != lit2->get_type ())
if (rcs_record_get_type (lit1) != rcs_record_get_type (lit2))
{
return false;
}
@@ -461,7 +484,6 @@ lit_literal_equal_type (literal_t lit1, /**< first literal */
return lit_literal_equal (lit1, lit2);
} /* lit_literal_equal_type */
/**
* Get the contents of the literal as a zero-terminated string.
* If literal is a magic string record, the corresponding string is not copied to the buffer,
@@ -470,39 +492,34 @@ lit_literal_equal_type (literal_t lit1, /**< first literal */
* @return pointer to the zero-terminated string.
*/
const lit_utf8_byte_t *
lit_literal_to_utf8_string (literal_t lit, /**< literal to be processed */
lit_literal_to_utf8_string (lit_literal_t lit, /**< literal to be processed */
lit_utf8_byte_t *buff_p, /**< buffer to use as a string storage */
size_t size) /**< size of the buffer */
{
JERRY_ASSERT (buff_p != NULL && size > 0);
rcs_record_t::type_t type = lit->get_type ();
rcs_record_type_t type = rcs_record_get_type (lit);
switch (type)
if (RCS_RECORD_TYPE_IS_CHARSET (type))
{
case LIT_STR_T:
{
lit_charset_record_t *ch_rec_p = static_cast<lit_charset_record_t *> (lit);
ch_rec_p->get_charset (buff_p, size);
return buff_p;
}
case LIT_MAGIC_STR_T:
{
return lit_get_magic_string_utf8 (lit_magic_record_get_magic_str_id (lit));
}
case LIT_MAGIC_STR_EX_T:
{
return lit_get_magic_string_ex_utf8 (lit_magic_record_ex_get_magic_str_id (lit));
}
case LIT_NUMBER_T:
{
ecma_number_to_utf8_string (static_cast<lit_number_record_t *> (lit)->get_number (), buff_p, (ssize_t)size);
return buff_p;
}
default: JERRY_UNREACHABLE ();
rcs_record_get_charset (&rcs_lit_storage, lit, buff_p, size);
return buff_p;
}
else if (RCS_RECORD_TYPE_IS_MAGIC_STR (type))
{
return lit_get_magic_string_utf8 (rcs_record_get_magic_str_id (lit));
}
else if (RCS_RECORD_TYPE_IS_MAGIC_STR_EX (type))
{
return lit_get_magic_string_ex_utf8 (rcs_record_get_magic_str_ex_id (lit));
}
else
{
JERRY_ASSERT (RCS_RECORD_TYPE_IS_NUMBER (type));
JERRY_UNREACHABLE ();
ecma_number_t number = rcs_record_get_number (&rcs_lit_storage, lit);
ecma_number_to_utf8_string (number, buff_p, (ssize_t) size);
return buff_p;
}
} /* lit_literal_to_utf8_string */
/**
@@ -512,7 +529,7 @@ lit_literal_to_utf8_string (literal_t lit, /**< literal to be processed */
* @return pointer to the C string.
*/
const char *
lit_literal_to_str_internal_buf (literal_t lit) /**< literal */
lit_literal_to_str_internal_buf (lit_literal_t lit) /**< literal */
{
static lit_utf8_byte_t buff[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER + 1];
memset (buff, 0, sizeof (buff));
@@ -528,11 +545,15 @@ lit_literal_to_str_internal_buf (literal_t lit) /**< literal */
* false otherwise
*/
static bool
lit_literal_exists (literal_t lit) /**< literal to check for existence */
lit_literal_exists (lit_literal_t lit) /**< literal to check for existence */
{
for (literal_t l = lit_storage.get_first (); l != NULL; l = lit_storage.get_next (l))
lit_literal_t current_lit;
for (current_lit = rcs_record_get_first (&rcs_lit_storage);
current_lit != NULL;
current_lit = rcs_record_get_next (&rcs_lit_storage, current_lit))
{
if (l == lit)
if (current_lit == lit)
{
return true;
}
@@ -546,39 +567,39 @@ lit_literal_exists (literal_t lit) /**< literal to check for existence */
*
* @return literal
*/
literal_t
lit_get_literal_by_cp (lit_cpointer_t lit_cp) /**< compressed pointer to literal */
lit_literal_t
lit_get_literal_by_cp (rcs_cpointer_t lit_cp) /**< compressed pointer to literal */
{
JERRY_ASSERT (lit_cp.packed_value != MEM_CP_NULL);
literal_t lit = lit_cpointer_t::decompress (lit_cp);
lit_literal_t lit = rcs_cpointer_decompress (lit_cp);
JERRY_ASSERT (lit_literal_exists (lit));
return lit;
} /* lit_get_literal_by_cp */
lit_string_hash_t
lit_charset_literal_get_hash (literal_t lit) /**< literal */
lit_charset_literal_get_hash (lit_literal_t lit) /**< literal */
{
return static_cast<lit_charset_record_t *> (lit)->get_hash ();
return rcs_record_get_hash (lit);
} /* lit_charset_literal_get_hash */
lit_magic_string_id_t
lit_magic_record_get_magic_str_id (literal_t lit) /**< literal */
lit_magic_literal_get_magic_str_id (lit_literal_t lit) /**< literal */
{
return static_cast<lit_magic_record_t *> (lit)->get_magic_str_id<lit_magic_string_id_t> ();
} /* lit_magic_record_get_magic_str_id */
return rcs_record_get_magic_str_id (lit);
} /* lit_magic_literal_get_magic_str_id */
lit_magic_string_ex_id_t
lit_magic_record_ex_get_magic_str_id (literal_t lit) /**< literal */
lit_magic_literal_ex_get_magic_str_id (lit_literal_t lit) /**< literal */
{
return static_cast<lit_magic_record_t *> (lit)->get_magic_str_id<lit_magic_string_ex_id_t> ();
} /* lit_magic_record_ex_get_magic_str_id */
return rcs_record_get_magic_str_ex_id (lit);
} /* lit_magic_literal_ex_get_magic_str_id */
lit_utf8_size_t
lit_charset_record_get_size (literal_t lit) /**< literal */
lit_charset_literal_get_size (lit_literal_t lit) /**< literal */
{
return static_cast<lit_charset_record_t *> (lit)->get_length ();
} /* lit_charset_record_get_size */
return rcs_record_get_length (lit);
} /* lit_charset_literal_get_size */
/**
* Get length of the literal
@@ -586,36 +607,40 @@ lit_charset_record_get_size (literal_t lit) /**< literal */
* @return code units count
*/
ecma_length_t
lit_charset_record_get_length (literal_t lit) /**< literal */
lit_charset_literal_get_length (lit_literal_t lit) /**< literal */
{
TODO ("Add special case for literals which doesn't contain long characters");
lit_charset_record_t *charset_record_p = static_cast<lit_charset_record_t *> (lit);
rcs_record_iterator_t lit_iter (&lit_storage, lit);
lit_iter.skip (lit_charset_record_t::header_size ());
rcs_iterator_t it_ctx = rcs_iterator_create (&rcs_lit_storage, lit);
rcs_iterator_skip (&it_ctx, RCS_CHARSET_HEADER_SIZE);
lit_utf8_size_t lit_utf8_str_size = charset_record_p->get_length ();
lit_utf8_size_t lit_utf8_str_size = rcs_record_get_length (lit);
ecma_length_t length = 0;
for (lit_utf8_size_t i = 0; i < lit_utf8_str_size;)
{
lit_utf8_byte_t byte = lit_iter.read <lit_utf8_byte_t> ();
lit_utf8_size_t bytes_to_skip = lit_get_unicode_char_size_by_utf8_first_byte (byte);
lit_iter.skip (bytes_to_skip);
i += bytes_to_skip;
lit_utf8_size_t i = 0;
while (i < lit_utf8_str_size)
{
lit_utf8_byte_t byte;
lit_utf8_size_t bytes_to_skip;
rcs_iterator_read (&it_ctx, &byte, sizeof (lit_utf8_byte_t));
bytes_to_skip = lit_get_unicode_char_size_by_utf8_first_byte (byte);
rcs_iterator_skip (&it_ctx, bytes_to_skip);
i += bytes_to_skip;
length += (bytes_to_skip > LIT_UTF8_MAX_BYTES_IN_CODE_UNIT) ? 2 : 1;
}
#ifndef JERRY_NDEBUG
lit_iter.skip (charset_record_p->get_alignment_bytes_count ());
JERRY_ASSERT (lit_iter.finished ());
rcs_iterator_skip (&it_ctx, rcs_record_get_alignment_bytes_count (lit));
JERRY_ASSERT (rcs_iterator_finished (&it_ctx));
#endif
return length;
} /* lit_charset_record_get_length */
} /* lit_charset_literal_get_length */
ecma_number_t
lit_charset_literal_get_number (literal_t lit) /**< literal */
lit_number_literal_get_number (lit_literal_t lit) /**< literal */
{
return static_cast<lit_number_record_t *> (lit)->get_number ();;
} /* lit_charset_literal_get_number */
return rcs_record_get_number (&rcs_lit_storage, lit);
} /* lit_number_literal_get_number */
jerry-core/lit/lit-literal.h
+26 -28
View File
@@ -16,42 +16,40 @@
#ifndef LIT_LITERAL_H
#define LIT_LITERAL_H
#include "lit-globals.h"
#include "lit-literal-storage.h"
#include "lit-magic-strings.h"
#include "ecma-globals.h"
void lit_init ();
void lit_finalize ();
void lit_dump_literals ();
extern void lit_init ();
extern void lit_finalize ();
extern void lit_dump_literals ();
literal_t lit_create_literal_from_utf8_string (const lit_utf8_byte_t *, lit_utf8_size_t);
literal_t lit_find_literal_by_utf8_string (const lit_utf8_byte_t *, lit_utf8_size_t);
literal_t lit_find_or_create_literal_from_utf8_string (const lit_utf8_byte_t *, lit_utf8_size_t);
extern lit_literal_t lit_create_literal_from_utf8_string (const lit_utf8_byte_t *, lit_utf8_size_t);
extern lit_literal_t lit_find_literal_by_utf8_string (const lit_utf8_byte_t *, lit_utf8_size_t);
extern lit_literal_t lit_find_or_create_literal_from_utf8_string (const lit_utf8_byte_t *, lit_utf8_size_t);
literal_t lit_create_literal_from_num (ecma_number_t);
literal_t lit_find_literal_by_num (ecma_number_t);
literal_t lit_find_or_create_literal_from_num (ecma_number_t);
extern lit_literal_t lit_create_literal_from_num (ecma_number_t);
extern lit_literal_t lit_find_literal_by_num (ecma_number_t);
extern lit_literal_t lit_find_or_create_literal_from_num (ecma_number_t);
bool lit_literal_equal_utf8 (literal_t, const lit_utf8_byte_t *, lit_utf8_size_t);
bool lit_literal_equal_num (literal_t, ecma_number_t);
bool lit_literal_equal (literal_t, literal_t);
extern bool lit_literal_equal_utf8 (lit_literal_t, const lit_utf8_byte_t *, lit_utf8_size_t);
extern bool lit_literal_equal_num (lit_literal_t, ecma_number_t);
extern bool lit_literal_equal (lit_literal_t, lit_literal_t);
bool lit_literal_equal_type_utf8 (literal_t, const lit_utf8_byte_t *, lit_utf8_size_t);
bool lit_literal_equal_type_cstr (literal_t, const char *);
bool lit_literal_equal_type_num (literal_t, ecma_number_t);
bool lit_literal_equal_type (literal_t, literal_t);
extern bool lit_literal_equal_type_utf8 (lit_literal_t, const lit_utf8_byte_t *, lit_utf8_size_t);
extern bool lit_literal_equal_type_cstr (lit_literal_t, const char *);
extern bool lit_literal_equal_type_num (lit_literal_t, ecma_number_t);
extern bool lit_literal_equal_type (lit_literal_t, lit_literal_t);
const lit_utf8_byte_t *lit_literal_to_utf8_string (literal_t, lit_utf8_byte_t *, size_t);
const char *lit_literal_to_str_internal_buf (literal_t);
extern const lit_utf8_byte_t *lit_literal_to_utf8_string (lit_literal_t, lit_utf8_byte_t *, size_t);
extern const char *lit_literal_to_str_internal_buf (lit_literal_t);
literal_t lit_get_literal_by_cp (lit_cpointer_t);
extern lit_literal_t lit_get_literal_by_cp (lit_cpointer_t);
lit_string_hash_t lit_charset_literal_get_hash (literal_t);
ecma_number_t lit_charset_literal_get_number (literal_t);
lit_utf8_size_t lit_charset_record_get_size (literal_t);
ecma_length_t lit_charset_record_get_length (literal_t);
extern ecma_number_t lit_number_literal_get_number (lit_literal_t);
extern lit_string_hash_t lit_charset_literal_get_hash (lit_literal_t);
extern lit_utf8_size_t lit_charset_literal_get_size (lit_literal_t);
extern ecma_length_t lit_charset_literal_get_length (lit_literal_t);
lit_magic_string_id_t lit_magic_record_get_magic_str_id (literal_t);
lit_magic_string_ex_id_t lit_magic_record_ex_get_magic_str_id (literal_t);
extern lit_magic_string_id_t lit_magic_literal_get_magic_str_id (lit_literal_t);
extern lit_magic_string_ex_id_t lit_magic_literal_ex_get_magic_str_id (lit_literal_t);
#endif /* LIT_LITERAL_H */
jerry-core/lit/lit-snapshot.cpp
+411
View File
@@ -0,0 +1,411 @@
/* Copyright 2015 Samsung Electronics Co., Ltd.
* Copyright 2015 University of Szeged
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "lit-snapshot.h"
#include "lit-literal.h"
#include "lit-literal-storage.h"
#include "rcs-allocator.h"
#include "rcs-iterator.h"
#include "rcs-records.h"
#ifdef JERRY_ENABLE_SNAPSHOT
/**
* Dump a record to specified snapshot buffer.
*
* @return number of bytes dumped,
* or 0 - upon dump failure
*/
static uint32_t
lit_snapshot_dump (lit_literal_t lit, /**< literal to dump */
uint8_t *buffer_p, /**< buffer to dump to */
size_t buffer_size, /**< buffer size */
size_t *in_out_buffer_offset_p) /**< in-out: buffer write offset */
{
rcs_record_type_t record_type = rcs_record_get_type (lit);
if (RCS_RECORD_TYPE_IS_NUMBER (record_type))
{
double num_value = rcs_record_get_number (&rcs_lit_storage, lit);
size_t size = sizeof (num_value);
if (!jrt_write_to_buffer_by_offset (buffer_p,
buffer_size,
in_out_buffer_offset_p,
&num_value,
size))
{
return 0;
}
return (uint32_t) size;
}
if (RCS_RECORD_TYPE_IS_CHARSET (record_type))
{
lit_utf8_size_t length = rcs_record_get_length (lit);
if (!jrt_write_to_buffer_by_offset (buffer_p,
buffer_size,
in_out_buffer_offset_p,
&length,
sizeof (length)))
{
return 0;
}
rcs_iterator_t it_ctx = rcs_iterator_create (&rcs_lit_storage, lit);
rcs_iterator_skip (&it_ctx, RCS_CHARSET_HEADER_SIZE);
lit_utf8_size_t i;
for (i = 0; i < length; ++i)
{
lit_utf8_byte_t next_byte;
rcs_iterator_read (&it_ctx, &next_byte, sizeof (lit_utf8_byte_t));
if (!jrt_write_to_buffer_by_offset (buffer_p,
buffer_size,
in_out_buffer_offset_p,
&next_byte,
sizeof (next_byte)))
{
return 0;
}
rcs_iterator_skip (&it_ctx, sizeof (lit_utf8_byte_t));
}
return (uint32_t) (sizeof (uint32_t) + length * sizeof (uint8_t));
}
if (RCS_RECORD_TYPE_IS_MAGIC_STR (record_type))
{
lit_magic_string_id_t id = rcs_record_get_magic_str_id (lit);
if (!jrt_write_to_buffer_by_offset (buffer_p,
buffer_size,
in_out_buffer_offset_p,
&id,
sizeof (id)))
{
return 0;
}
return (uint32_t) sizeof (lit_magic_string_id_t);
}
if (RCS_RECORD_TYPE_IS_MAGIC_STR_EX (record_type))
{
lit_magic_string_ex_id_t id = rcs_record_get_magic_str_ex_id (lit);
if (!jrt_write_to_buffer_by_offset (buffer_p,
buffer_size,
in_out_buffer_offset_p,
&id,
sizeof (id)))
{
return 0;
}
return (uint32_t) sizeof (lit_magic_string_ex_id_t);
}
JERRY_UNREACHABLE ();
return 0;
} /* rcs_snapshot_dump */
/**
* Dump literals to specified snapshot buffer.
*
* @return true, if dump was performed successfully (i.e. buffer size is sufficient),
* false - otherwise.
*/
bool
lit_dump_literals_for_snapshot (uint8_t *buffer_p, /**< output snapshot buffer */
size_t buffer_size, /**< size of the buffer */
size_t *in_out_buffer_offset_p, /**< in-out: write position in the buffer */
lit_mem_to_snapshot_id_map_entry_t **out_map_p, /**< out: map from literal identifiers
* to the literal offsets
* in snapshot */
uint32_t *out_map_num_p, /**< out: number of literals */
uint32_t *out_lit_table_size_p) /**< out: number of bytes, dumped to snapshot buffer */
{
uint32_t literals_num = lit_count_literals (&rcs_lit_storage);
uint32_t lit_table_size = 0;
*out_map_p = NULL;
*out_map_num_p = 0;
*out_lit_table_size_p = 0;
if (!jrt_write_to_buffer_by_offset (buffer_p,
buffer_size,
in_out_buffer_offset_p,
&literals_num,
sizeof (literals_num)))
{
return false;
}
lit_table_size += (uint32_t) sizeof (literals_num);
if (literals_num != 0)
{
bool is_ok = true;
size_t id_map_size = sizeof (lit_mem_to_snapshot_id_map_entry_t) * literals_num;
lit_mem_to_snapshot_id_map_entry_t *id_map_p;
id_map_p = (lit_mem_to_snapshot_id_map_entry_t *) mem_heap_alloc_block (id_map_size, MEM_HEAP_ALLOC_SHORT_TERM);
uint32_t literal_index = 0;
lit_literal_t lit;
for (lit = rcs_record_get_first (&rcs_lit_storage);
lit != NULL;
lit = rcs_record_get_next (&rcs_lit_storage, lit))
{
rcs_record_type_t record_type = rcs_record_get_type (lit);
if (RCS_RECORD_TYPE_IS_FREE (record_type))
{
continue;
}
if (!jrt_write_to_buffer_by_offset (buffer_p,
buffer_size,
in_out_buffer_offset_p,
&record_type,
sizeof (record_type)))
{
is_ok = false;
break;
}
uint32_t bytes = lit_snapshot_dump (lit, buffer_p, buffer_size, in_out_buffer_offset_p);
if (bytes == 0)
{
/* write failed */
is_ok = false;
break;
}
rcs_cpointer_t lit_cp = rcs_cpointer_compress (lit);
id_map_p[literal_index].literal_id = lit_cp;
id_map_p[literal_index].literal_offset = lit_table_size;
lit_table_size += (uint32_t) sizeof (record_type);
lit_table_size += bytes;
literal_index++;
}
if (!is_ok)
{
mem_heap_free_block (id_map_p);
return false;
}
JERRY_ASSERT (literal_index == literals_num);
*out_map_p = id_map_p;
}
uint32_t aligned_size = JERRY_ALIGNUP (lit_table_size, MEM_ALIGNMENT);
if (aligned_size != lit_table_size)
{
JERRY_ASSERT (aligned_size > lit_table_size);
uint8_t padding = 0;
uint32_t padding_bytes_num = (uint32_t) (aligned_size - lit_table_size);
uint32_t i;
for (i = 0; i < padding_bytes_num; i++)
{
if (!jrt_write_to_buffer_by_offset (buffer_p,
buffer_size,
in_out_buffer_offset_p,
&padding,
sizeof (uint8_t)))
{
return false;
}
}
}
*out_map_num_p = literals_num;
*out_lit_table_size_p = aligned_size;
return true;
} /* lit_dump_literals_for_snapshot */
/**
* Load literals from snapshot.
*
* @return true, if load was performed successfully (i.e. literals dump in the snapshot is consistent),
* false - otherwise (i.e. snapshot is incorrect).
*/
bool
lit_load_literals_from_snapshot (const uint8_t *lit_table_p, /**< buffer with literal table in snapshot */
uint32_t lit_table_size, /**< size of literal table in snapshot */
lit_mem_to_snapshot_id_map_entry_t **out_map_p, /**< out: map from literal offsets
* in snapshot to identifiers
* of loaded literals in literal
* storage */
uint32_t *out_map_num_p) /**< out: literals number */
{
*out_map_p = NULL;
*out_map_num_p = 0;
size_t lit_table_read = 0;
uint32_t literals_num;
if (!jrt_read_from_buffer_by_offset (lit_table_p,
lit_table_size,
&lit_table_read,
&literals_num,
sizeof (literals_num)))
{
return false;
}
if (literals_num == 0)
{
return true;
}
size_t id_map_size = sizeof (lit_mem_to_snapshot_id_map_entry_t) * literals_num;
lit_mem_to_snapshot_id_map_entry_t *id_map_p;
id_map_p = (lit_mem_to_snapshot_id_map_entry_t *) mem_heap_alloc_block (id_map_size, MEM_HEAP_ALLOC_SHORT_TERM);
bool is_ok = true;
uint32_t lit_index;
for (lit_index = 0; lit_index < literals_num; ++lit_index)
{
uint32_t offset = (uint32_t) lit_table_read;
JERRY_ASSERT (offset == lit_table_read);
rcs_record_type_t type;
if (!jrt_read_from_buffer_by_offset (lit_table_p,
lit_table_size,
&lit_table_read,
&type,
sizeof (type)))
{
is_ok = false;
break;
}
lit_literal_t lit;
if (RCS_RECORD_TYPE_IS_CHARSET (type))
{
lit_utf8_size_t length;
if (!jrt_read_from_buffer_by_offset (lit_table_p,
lit_table_size,
&lit_table_read,
&length,
sizeof (length))
|| (lit_table_read + length > lit_table_size))
{
is_ok = false;
break;
}
lit = (lit_literal_t) lit_find_or_create_literal_from_utf8_string (lit_table_p + lit_table_read, length);
lit_table_read += length;
}
else if (RCS_RECORD_TYPE_IS_MAGIC_STR (type))
{
lit_magic_string_id_t id;
if (!jrt_read_from_buffer_by_offset (lit_table_p,
lit_table_size,
&lit_table_read,
&id,
sizeof (id)))
{
is_ok = false;
break;
}
const lit_utf8_byte_t *magic_str_p = lit_get_magic_string_utf8 (id);
lit_utf8_size_t magic_str_sz = lit_get_magic_string_size (id);
/*
* TODO:
* Consider searching literal storage by magic string identifier instead of by its value
*/
lit = (lit_literal_t) lit_find_or_create_literal_from_utf8_string (magic_str_p, magic_str_sz);
}
else if (RCS_RECORD_TYPE_IS_MAGIC_STR_EX (type))
{
lit_magic_string_ex_id_t id;
if (!jrt_read_from_buffer_by_offset (lit_table_p,
lit_table_size,
&lit_table_read,
&id,
sizeof (id)))
{
is_ok = false;
break;
}
const lit_utf8_byte_t *magic_str_ex_p = lit_get_magic_string_ex_utf8 (id);
lit_utf8_size_t magic_str_ex_sz = lit_get_magic_string_ex_size (id);
/*
* TODO:
* Consider searching literal storage by magic string identifier instead of by its value
*/
lit = (lit_literal_t) lit_find_or_create_literal_from_utf8_string (magic_str_ex_p, magic_str_ex_sz);
}
else if (RCS_RECORD_TYPE_IS_NUMBER (type))
{
double num;
if (!jrt_read_from_buffer_by_offset (lit_table_p,
lit_table_size,
&lit_table_read,
&num,
sizeof (num)))
{
is_ok = false;
break;
}
lit = (lit_literal_t) lit_find_or_create_literal_from_num ((ecma_number_t) num);
}
else
{
is_ok = false;
break;
}
id_map_p[lit_index].literal_offset = offset;
id_map_p[lit_index].literal_id = rcs_cpointer_compress (lit);
}
if (is_ok)
{
*out_map_p = id_map_p;
*out_map_num_p = literals_num;
return true;
}
mem_heap_free_block (id_map_p);
return false;
} /* rcs_load_literals_from_snapshot */
#endif /* JERRY_ENABLE_SNAPSHOT */
jerry-core/lit/lit-snapshot.h
+44
View File
@@ -0,0 +1,44 @@
/* Copyright 2015 Samsung Electronics Co., Ltd.
* Copyright 2015 University of Szeged
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef RCS_SNAPSHOT_H
#define RCS_SNAPSHOT_H
#include "rcs-cpointer.h"
typedef struct
{
rcs_cpointer_t literal_id;
uint32_t literal_offset;
} lit_mem_to_snapshot_id_map_entry_t;
#ifdef JERRY_ENABLE_SNAPSHOT
extern bool
lit_dump_literals_for_snapshot (uint8_t *,
size_t,
size_t *,
lit_mem_to_snapshot_id_map_entry_t **,
uint32_t *,
uint32_t *);
extern bool
lit_load_literals_from_snapshot (const uint8_t *,
uint32_t,
lit_mem_to_snapshot_id_map_entry_t **,
uint32_t *);
#endif /* JERRY_ENABLE_SNAPSHOT */
#endif /* !RCS_SNAPSHOT_H */