Follow-up refactoring of logging-related parts

This patch:
* Ensures that all calls to `jerry_port_log` in jerry-core happen
  via macros defined in jrt.h. Also, it unifies the names of those
  macros: as `JERRY_ERROR_MSG` and `JERRY_WARNING_MSG` gave a good
  pattern that was well aligned with the naming scheme of the log
  level enum, `JERRY_DLOG` and `JERRY_DDLOG` were rewritten to
  `JERRY_DEBUG_MSG` and `JERRY_TRACE_MSG`.
* Ensures that all debug logging code parts of jerry-core (i.e.,
  memory statistics, JS byte-code dumps, and RegExp byte-code
  dumps) are guarded by macros: `JMEM_STATS`,
  `PARSER_DUMP_BYTE_CODE`, and `REGEXP_DUMP_BYTE_CODE`, which in
  turn are controled by cmake build system feature flags
  `FEATURE_MEM_STATS`, `FEATURE_PARSER_DUMP`, and
  `FEATURE_REGEXP_DUMP`.
* Ensures that all debug logging functionalities can be controled
  during run time (provided that they were enabled during build
  time): the engine has `JERRY_INIT_MEM_STATS[_SEPARATE]`,
  `JERRY_INIT_SHOW_OPCODES`, `JERRY_INIT_SHOW_REGEXP_OPCODES` init
  flags, and the default unix/linux command line app has
  corresponding command line switches.`
* Drops `FEATURE_LOG`, `JERRY_ENABLE_LOG`, and
  `JERRY_INIT_ENABLE_LOG`, as their name was misleadingly general,
  even though they mostly controled the regexp engine only. The
  above-mentioned `*REGEXP*` things mostly act as their
  replacements.
* Updates build, test, and measurement tool scripts, and
  documentation.

JerryScript-DCO-1.0-Signed-off-by: Akos Kiss akiss@inf.u-szeged.hu

30 files changed, 333 insertions, 362 deletions

diff --git a/docs/02.API-REFERENCE.md b/docs/02.API-REFERENCE.md
index f968caf6..e8e75b17 100644
--- a/docs/02.API-REFERENCE.md
+++ b/docs/02.API-REFERENCE.md
@@ -5,8 +5,8 @@
 Enum that contains the following elements:
 
  - JERRY_INIT_EMPTY - empty flag set
- - JERRY_INIT_ENABLE_LOG - enable logging
- - JERRY_INIT_SHOW_OPCODES - dump byte-code to stdout after parse
+ - JERRY_INIT_SHOW_OPCODES - dump byte-code to log after parse
+ - JERRY_INIT_SHOW_REGEXP_OPCODES - dump regexp byte-code to log after compilation
  - JERRY_INIT_MEM_STATS - dump memory statistics
  - JERRY_INIT_MEM_STATS_SEPARATE - dump memory statistics and reset peak values after parse
 
@@ -181,8 +181,8 @@ jerry_init (jerry_init_flag_t flags)
 `flags` - combination of various engine configuration flags:
 
 - `JERRY_INIT_EMPTY` - no flags, just initialize in default configuration.
-- `JERRY_INIT_ENABLE_LOG` - enable logging.
 - `JERRY_INIT_SHOW_OPCODES` - print compiled byte-code.
+- `JERRY_INIT_SHOW_REGEXP_OPCODES` - print compiled regexp byte-code.
 - `JERRY_INIT_MEM_STATS` - dump memory statistics.
 - `JERRY_INIT_MEM_STATS_SEPARATE` - dump memory statistics and reset peak values after parse.
 
@@ -190,7 +190,7 @@ jerry_init (jerry_init_flag_t flags)
 
 ```c
 {
-  jerry_init (JERRY_INIT_SHOW_OPCODES | JERRY_INIT_ENABLE_LOG);
+  jerry_init (JERRY_INIT_SHOW_OPCODES | JERRY_INIT_SHOW_REGEXP_OPCODES);
 
   // ...
 
diff --git a/jerry-core/CMakeLists.txt b/jerry-core/CMakeLists.txt
index dcee5285..326cc0c3 100644
--- a/jerry-core/CMakeLists.txt
+++ b/jerry-core/CMakeLists.txt
@@ -20,11 +20,12 @@ project (${JERRY_CORE_NAME} C)
 # Optional features
 set(FEATURE_PROFILE         "full" CACHE STRING "Profile types: full, minimal")
 set(FEATURE_ERROR_MESSAGES  OFF    CACHE BOOL   "Enable error messages?")
-set(FEATURE_LOG             OFF    CACHE BOOL   "Enable logging?")
 set(FEATURE_VALGRIND        OFF    CACHE BOOL   "Enable Valgrind support?")
 set(FEATURE_VALGRIND_FREYA  OFF    CACHE BOOL   "Enable Valgrind-Freya support?")
 set(FEATURE_MEM_STRESS_TEST OFF    CACHE BOOL   "Enable mem-stress test?")
-set(FEATURE_MEM_STATS       OFF    CACHE BOOL   "Enable memory-statistics?")
+set(FEATURE_MEM_STATS       OFF    CACHE BOOL   "Enable memory statistics?")
+set(FEATURE_PARSER_DUMP     OFF    CACHE BOOL   "Enable parser byte-code dumps?")
+set(FEATURE_REGEXP_DUMP     OFF    CACHE BOOL   "Enable regexp byte-code dumps?")
 set(FEATURE_SNAPSHOT_SAVE   OFF    CACHE BOOL   "Allow to save snapshot files?")
 set(FEATURE_SNAPSHOT_EXEC   OFF    CACHE BOOL   "Allow to execute snapshot files?")
 set(MEM_HEAP_SIZE_KB        "512"  CACHE STRING "Size of memory heap, in kilobytes")
@@ -32,11 +33,12 @@ set(MEM_HEAP_SIZE_KB        "512"  CACHE STRING "Size of memory heap, in kilobyt
 # Status messages
 message(STATUS "FEATURE_PROFILE           " ${FEATURE_PROFILE})
 message(STATUS "FEATURE_ERROR_MESSAGES    " ${FEATURE_ERROR_MESSAGES})
-message(STATUS "FEATURE_LOG               " ${FEATURE_LOG})
 message(STATUS "FEATURE_VALGRIND          " ${FEATURE_VALGRIND})
 message(STATUS "FEATURE_VALGRIND_FREYA    " ${FEATURE_VALGRIND_FREYA})
 message(STATUS "FEATURE_MEM_STRESS_TEST   " ${FEATURE_MEM_STRESS_TEST})
 message(STATUS "FEATURE_MEM_STATS         " ${FEATURE_MEM_STATS})
+message(STATUS "FEATURE_PARSER_DUMP       " ${FEATURE_PARSER_DUMP})
+message(STATUS "FEATURE_REGEXP_DUMP       " ${FEATURE_REGEXP_DUMP})
 message(STATUS "FEATURE_SNAPSHOT_SAVE     " ${FEATURE_SNAPSHOT_SAVE})
 message(STATUS "FEATURE_SNAPSHOT_EXEC     " ${FEATURE_SNAPSHOT_EXEC})
 message(STATUS "MEM_HEAP_SIZE_KB          " ${MEM_HEAP_SIZE_KB})
@@ -170,11 +172,6 @@ if(FEATURE_ERROR_MESSAGES)
   set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_ENABLE_ERROR_MESSAGES)
 endif()
 
-# Log
-if(FEATURE_LOG)
-  set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_ENABLE_LOG)
-endif()
-
 # Valgrind
 if(FEATURE_VALGRIND)
   set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_VALGRIND)
@@ -197,6 +194,16 @@ if(FEATURE_MEM_STATS)
   set(DEFINES_JERRY ${DEFINES_JERRY} JMEM_STATS)
 endif()
 
+# Parser byte-code dumps
+if(FEATURE_PARSER_DUMP)
+  set(DEFINES_JERRY ${DEFINES_JERRY} PARSER_DUMP_BYTE_CODE)
+endif()
+
+# RegExp byte-code dumps
+if(FEATURE_REGEXP_DUMP)
+  set(DEFINES_JERRY ${DEFINES_JERRY} REGEXP_DUMP_BYTE_CODE)
+endif()
+
 # Snapshot save
 if(FEATURE_SNAPSHOT_SAVE)
   set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_ENABLE_SNAPSHOT_SAVE)
diff --git a/jerry-core/ecma/operations/ecma-regexp-object.c b/jerry-core/ecma/operations/ecma-regexp-object.c
index 195e1af6..0210940e 100644
--- a/jerry-core/ecma/operations/ecma-regexp-object.c
+++ b/jerry-core/ecma/operations/ecma-regexp-object.c
@@ -385,7 +385,7 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
     {
       case RE_OP_MATCH:
       {
-        JERRY_DDLOG ("Execute RE_OP_MATCH: match\n");
+        JERRY_TRACE_MSG ("Execute RE_OP_MATCH: match\n");
         *out_str_p = str_curr_p;
         ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_TRUE);
         return ret_value; /* match */
@@ -400,15 +400,15 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
         bool is_ignorecase = re_ctx_p->flags & RE_FLAG_IGNORE_CASE;
         ecma_char_t ch1 = (ecma_char_t) re_get_char (&bc_p); /* Already canonicalized. */
         ecma_char_t ch2 = re_canonicalize (lit_utf8_read_next (&str_curr_p), is_ignorecase);
-        JERRY_DDLOG ("Character matching %d to %d: ", ch1, ch2);
+        JERRY_TRACE_MSG ("Character matching %d to %d: ", ch1, ch2);
 
         if (ch1 != ch2)
         {
-          JERRY_DDLOG ("fail\n");
+          JERRY_TRACE_MSG ("fail\n");
           return ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
         }
 
-        JERRY_DDLOG ("match\n");
+        JERRY_TRACE_MSG ("match\n");
 
         break; /* tail merge */
       }
@@ -420,65 +420,65 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
         }
 
         ecma_char_t ch = lit_utf8_read_next (&str_curr_p);
-        JERRY_DDLOG ("Period matching '.' to %d: ", (uint32_t) ch);
+        JERRY_TRACE_MSG ("Period matching '.' to %d: ", (uint32_t) ch);
 
         if (lit_char_is_line_terminator (ch))
         {
-          JERRY_DDLOG ("fail\n");
+          JERRY_TRACE_MSG ("fail\n");
           return ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
         }
 
-        JERRY_DDLOG ("match\n");
+        JERRY_TRACE_MSG ("match\n");
         break; /* tail merge */
       }
       case RE_OP_ASSERT_START:
       {
-        JERRY_DDLOG ("Execute RE_OP_ASSERT_START: ");
+        JERRY_TRACE_MSG ("Execute RE_OP_ASSERT_START: ");
 
         if (str_curr_p <= re_ctx_p->input_start_p)
         {
-          JERRY_DDLOG ("match\n");
+          JERRY_TRACE_MSG ("match\n");
           break; /* tail merge */
         }
 
         if (!(re_ctx_p->flags & RE_FLAG_MULTILINE))
         {
-          JERRY_DDLOG ("fail\n");
+          JERRY_TRACE_MSG ("fail\n");
           return ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
         }
 
         if (lit_char_is_line_terminator (lit_utf8_peek_prev (str_curr_p)))
         {
-          JERRY_DDLOG ("match\n");
+          JERRY_TRACE_MSG ("match\n");
           break; /* tail merge */
         }
 
-        JERRY_DDLOG ("fail\n");
+        JERRY_TRACE_MSG ("fail\n");
         return ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
       }
       case RE_OP_ASSERT_END:
       {
-        JERRY_DDLOG ("Execute RE_OP_ASSERT_END: ");
+        JERRY_TRACE_MSG ("Execute RE_OP_ASSERT_END: ");
 
         if (str_curr_p >= re_ctx_p->input_end_p)
         {
-          JERRY_DDLOG ("match\n");
+          JERRY_TRACE_MSG ("match\n");
           break; /* tail merge */
         }
 
         if (!(re_ctx_p->flags & RE_FLAG_MULTILINE))
         {
-          JERRY_DDLOG ("fail\n");
+          JERRY_TRACE_MSG ("fail\n");
           return ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
         }
 
         if (lit_char_is_line_terminator (lit_utf8_peek_next (str_curr_p)))
         {
-          JERRY_DDLOG ("match\n");
+          JERRY_TRACE_MSG ("match\n");
           break; /* tail merge */
         }
 
-        JERRY_DDLOG ("fail\n");
+        JERRY_TRACE_MSG ("fail\n");
         return ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
       }
       case RE_OP_ASSERT_WORD_BOUNDARY:
@@ -506,26 +506,26 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
 
         if (op == RE_OP_ASSERT_WORD_BOUNDARY)
         {
-          JERRY_DDLOG ("Execute RE_OP_ASSERT_WORD_BOUNDARY: ");
+          JERRY_TRACE_MSG ("Execute RE_OP_ASSERT_WORD_BOUNDARY: ");
           if (is_wordchar_left == is_wordchar_right)
           {
-            JERRY_DDLOG ("fail\n");
+            JERRY_TRACE_MSG ("fail\n");
             return ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
           }
         }
         else
         {
           JERRY_ASSERT (op == RE_OP_ASSERT_NOT_WORD_BOUNDARY);
-          JERRY_DDLOG ("Execute RE_OP_ASSERT_NOT_WORD_BOUNDARY: ");
+          JERRY_TRACE_MSG ("Execute RE_OP_ASSERT_NOT_WORD_BOUNDARY: ");
 
           if (is_wordchar_left != is_wordchar_right)
           {
-            JERRY_DDLOG ("fail\n");
+            JERRY_TRACE_MSG ("fail\n");
             return ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
           }
         }
 
-        JERRY_DDLOG ("match\n");
+        JERRY_TRACE_MSG ("match\n");
         break; /* tail merge */
       }
       case RE_OP_LOOKAHEAD_POS:
@@ -558,17 +558,17 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
 
         if (!ECMA_IS_VALUE_ERROR (match_value))
         {
-          JERRY_DDLOG ("Execute RE_OP_LOOKAHEAD_POS/NEG: ");
+          JERRY_TRACE_MSG ("Execute RE_OP_LOOKAHEAD_POS/NEG: ");
           ecma_free_value (match_value);
           if ((op == RE_OP_LOOKAHEAD_POS && sub_str_p)
               || (op == RE_OP_LOOKAHEAD_NEG && !sub_str_p))
           {
-            JERRY_DDLOG ("match\n");
+            JERRY_TRACE_MSG ("match\n");
             match_value = re_match_regexp (re_ctx_p, bc_p, str_curr_p, &sub_str_p);
           }
           else
           {
-            JERRY_DDLOG ("fail\n");
+            JERRY_TRACE_MSG ("fail\n");
             match_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
           }
         }
@@ -596,10 +596,10 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
         uint32_t num_of_ranges;
         bool is_match;
 
-        JERRY_DDLOG ("Execute RE_OP_CHAR_CLASS/RE_OP_INV_CHAR_CLASS, ");
+        JERRY_TRACE_MSG ("Execute RE_OP_CHAR_CLASS/RE_OP_INV_CHAR_CLASS, ");
         if (str_curr_p >= re_ctx_p->input_end_p)
         {
-          JERRY_DDLOG ("fail\n");
+          JERRY_TRACE_MSG ("fail\n");
           return ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
         }
 
@@ -613,8 +613,8 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
         {
           ecma_char_t ch1 = re_canonicalize (re_get_char (&bc_p), is_ignorecase);
           ecma_char_t ch2 = re_canonicalize (re_get_char (&bc_p), is_ignorecase);
-          JERRY_DDLOG ("num_of_ranges=%d, ch1=%d, ch2=%d, curr_ch=%d; ",
-                       num_of_ranges, ch1, ch2, curr_ch);
+          JERRY_TRACE_MSG ("num_of_ranges=%d, ch1=%d, ch2=%d, curr_ch=%d; ",
+                           num_of_ranges, ch1, ch2, curr_ch);
 
           if (curr_ch >= ch1 && curr_ch <= ch2)
           {
@@ -628,7 +628,7 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
         {
           if (!is_match)
           {
-            JERRY_DDLOG ("fail\n");
+            JERRY_TRACE_MSG ("fail\n");
             return ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
           }
         }
@@ -637,11 +637,11 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
           JERRY_ASSERT (op == RE_OP_INV_CHAR_CLASS);
           if (is_match)
           {
-            JERRY_DDLOG ("fail\n");
+            JERRY_TRACE_MSG ("fail\n");
             return ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
           }
         }
-        JERRY_DDLOG ("match\n");
+        JERRY_TRACE_MSG ("match\n");
         break; /* tail merge */
       }
       case RE_OP_BACKREFERENCE:
@@ -649,13 +649,13 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
         uint32_t backref_idx;
 
         backref_idx = re_get_value (&bc_p);
-        JERRY_DDLOG ("Execute RE_OP_BACKREFERENCE (idx: %d): ", backref_idx);
+        JERRY_TRACE_MSG ("Execute RE_OP_BACKREFERENCE (idx: %d): ", backref_idx);
         backref_idx *= 2;  /* backref n -> saved indices [n*2, n*2+1] */
         JERRY_ASSERT (backref_idx >= 2 && backref_idx + 1 < re_ctx_p->num_of_captures);
 
         if (!re_ctx_p->saved_p[backref_idx] || !re_ctx_p->saved_p[backref_idx + 1])
         {
-          JERRY_DDLOG ("match\n");
+          JERRY_TRACE_MSG ("match\n");
           break; /* capture is 'undefined', always matches! */
         }
 
@@ -667,7 +667,7 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
 
           if (str_curr_p >= re_ctx_p->input_end_p)
           {
-            JERRY_DDLOG ("fail\n");
+            JERRY_TRACE_MSG ("fail\n");
             return ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
           }
 
@@ -676,18 +676,18 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
 
           if (ch1 != ch2)
           {
-            JERRY_DDLOG ("fail\n");
+            JERRY_TRACE_MSG ("fail\n");
             return ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
           }
         }
-        JERRY_DDLOG ("match\n");
+        JERRY_TRACE_MSG ("match\n");
         break; /* tail merge */
       }
       case RE_OP_SAVE_AT_START:
       {
         uint8_t *old_bc_p;
 
-        JERRY_DDLOG ("Execute RE_OP_SAVE_AT_START\n");
+        JERRY_TRACE_MSG ("Execute RE_OP_SAVE_AT_START\n");
         const lit_utf8_byte_t *old_start_p = re_ctx_p->saved_p[RE_GLOBAL_START_IDX];
         re_ctx_p->saved_p[RE_GLOBAL_START_IDX] = str_curr_p;
 
@@ -718,7 +718,7 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
       }
       case RE_OP_SAVE_AND_MATCH:
       {
-        JERRY_DDLOG ("End of pattern is reached: match\n");
+        JERRY_TRACE_MSG ("End of pattern is reached: match\n");
         re_ctx_p->saved_p[RE_GLOBAL_END_IDX] = str_curr_p;
         *out_str_p = str_curr_p;
         return ecma_make_simple_value (ECMA_SIMPLE_VALUE_TRUE); /* match */
@@ -729,18 +729,18 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
         *  Alternatives should be jump over, when alternative opcode appears.
         */
         uint32_t offset = re_get_value (&bc_p);
-        JERRY_DDLOG ("Execute RE_OP_ALTERNATIVE");
+        JERRY_TRACE_MSG ("Execute RE_OP_ALTERNATIVE");
         bc_p += offset;
 
         while (*bc_p == RE_OP_ALTERNATIVE)
         {
-          JERRY_DDLOG (", jump: %d");
+          JERRY_TRACE_MSG (", jump: %d");
           bc_p++;
           offset = re_get_value (&bc_p);
           bc_p += offset;
         }
 
-        JERRY_DDLOG ("\n");
+        JERRY_TRACE_MSG ("\n");
         break; /* tail merge */
       }
       case RE_OP_CAPTURE_NON_GREEDY_ZERO_GROUP_START:
@@ -1057,8 +1057,8 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
         max = re_get_value (&bc_p);
 
         offset = re_get_value (&bc_p);
-        JERRY_DDLOG ("Non-greedy iterator, min=%lu, max=%lu, offset=%ld\n",
-                     (unsigned long) min, (unsigned long) max, (long) offset);
+        JERRY_TRACE_MSG ("Non-greedy iterator, min=%lu, max=%lu, offset=%ld\n",
+                         (unsigned long) min, (unsigned long) max, (long) offset);
 
         num_of_iter = 0;
         while (num_of_iter <= max)
@@ -1104,8 +1104,8 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
         max = re_get_value (&bc_p);
 
         offset = re_get_value (&bc_p);
-        JERRY_DDLOG ("Greedy iterator, min=%lu, max=%lu, offset=%ld\n",
-                     (unsigned long) min, (unsigned long) max, (long) offset);
+        JERRY_TRACE_MSG ("Greedy iterator, min=%lu, max=%lu, offset=%ld\n",
+                         (unsigned long) min, (unsigned long) max, (long) offset);
 
         num_of_iter = 0;
 
@@ -1153,7 +1153,7 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
       }
       default:
       {
-        JERRY_DDLOG ("UNKNOWN opcode (%d)!\n", (uint32_t) op);
+        JERRY_TRACE_MSG ("UNKNOWN opcode (%d)!\n", (uint32_t) op);
         return ecma_raise_common_error (ECMA_ERR_MSG (""));
       }
     }
@@ -1278,10 +1278,10 @@ ecma_regexp_exec_helper (ecma_value_t regexp_value, /**< RegExp object */
     re_ctx.flags &= (uint16_t) ~RE_FLAG_GLOBAL;
   }
 
-  JERRY_DDLOG ("Exec with flags [global: %d, ignoreCase: %d, multiline: %d]\n",
-               re_ctx.flags & RE_FLAG_GLOBAL,
-               re_ctx.flags & RE_FLAG_IGNORE_CASE,
-               re_ctx.flags & RE_FLAG_MULTILINE);
+  JERRY_TRACE_MSG ("Exec with flags [global: %d, ignoreCase: %d, multiline: %d]\n",
+                   re_ctx.flags & RE_FLAG_GLOBAL,
+                   re_ctx.flags & RE_FLAG_IGNORE_CASE,
+                   re_ctx.flags & RE_FLAG_MULTILINE);
 
   re_ctx.num_of_captures = bc_p->num_of_captures;
   JERRY_ASSERT (re_ctx.num_of_captures % 2 == 0);
diff --git a/jerry-core/jerry-api.h b/jerry-core/jerry-api.h
index a4bc998d..1ff73628 100644
--- a/jerry-core/jerry-api.h
+++ b/jerry-core/jerry-api.h
@@ -47,11 +47,11 @@ extern "C"
  */
 typedef enum
 {
-  JERRY_INIT_EMPTY              = (0u),      /**< empty flag set */
-  JERRY_INIT_ENABLE_LOG         = (1u << 0), /**< enable logging */
-  JERRY_INIT_SHOW_OPCODES       = (1u << 1), /**< dump byte-code to stdout after parse */
-  JERRY_INIT_MEM_STATS          = (1u << 2), /**< dump memory statistics */
-  JERRY_INIT_MEM_STATS_SEPARATE = (1u << 3), /**< dump memory statistics and reset peak values after parse */
+  JERRY_INIT_EMPTY               = (0u),      /**< empty flag set */
+  JERRY_INIT_SHOW_OPCODES        = (1u << 0), /**< dump byte-code to log after parse */
+  JERRY_INIT_SHOW_REGEXP_OPCODES = (1u << 1), /**< dump regexp byte-code to log after compilation */
+  JERRY_INIT_MEM_STATS           = (1u << 2), /**< dump memory statistics */
+  JERRY_INIT_MEM_STATS_SEPARATE  = (1u << 3), /**< dump memory statistics and reset peak values after parse */
 } jerry_init_flag_t;
 
 /**
diff --git a/jerry-core/jerry.c b/jerry-core/jerry.c
index 7ea33031..b0bdbbb2 100644
--- a/jerry-core/jerry.c
+++ b/jerry-core/jerry.c
@@ -143,27 +143,36 @@ jerry_init (jerry_init_flag_t flags) /**< combination of Jerry flags */
   /* Zero out all members. */
   memset (&JERRY_CONTEXT (JERRY_CONTEXT_FIRST_MEMBER), 0, sizeof (jerry_context_t));
 
-  if (flags & (JERRY_INIT_ENABLE_LOG))
-  {
-#ifndef JERRY_ENABLE_LOG
-    JERRY_WARNING_MSG ("Ignoring log options because of '!JERRY_ENABLE_LOG' build configuration.\n");
-#endif /* !JERRY_ENABLE_LOG */
-  }
-
   if (flags & (JERRY_INIT_MEM_STATS | JERRY_INIT_MEM_STATS_SEPARATE))
   {
 #ifndef JMEM_STATS
     flags &= (jerry_init_flag_t) ~(JERRY_INIT_MEM_STATS | JERRY_INIT_MEM_STATS_SEPARATE);
 
-    JERRY_WARNING_MSG ("Ignoring memory statistics option because of '!JMEM_STATS' build configuration.\n");
+    JERRY_WARNING_MSG ("Ignoring JERRY_INIT_MEM_STATS flag because of !JMEM_STATS configuration.\n");
 #else /* JMEM_STATS */
-    if (flags & JERRY_INIT_MEM_STATS_SEPARATE)
-    {
-      flags |= JERRY_INIT_MEM_STATS;
-    }
+    flags |= JERRY_INIT_MEM_STATS;
 #endif /* !JMEM_STATS */
   }
 
+  if (flags & JERRY_INIT_SHOW_OPCODES)
+  {
+#ifndef PARSER_DUMP_BYTE_CODE
+    flags &= (jerry_init_flag_t) ~JERRY_INIT_SHOW_OPCODES;
+
+    JERRY_WARNING_MSG ("Ignoring JERRY_INIT_SHOW_OPCODES flag because of !PARSER_DUMP_BYTE_CODE configuration.\n");
+#endif /* !PARSER_DUMP_BYTE_CODE */
+  }
+
+  if (flags & JERRY_INIT_SHOW_REGEXP_OPCODES)
+  {
+#ifndef REGEXP_DUMP_BYTE_CODE
+    flags &= (jerry_init_flag_t) ~JERRY_INIT_SHOW_REGEXP_OPCODES;
+
+    JERRY_WARNING_MSG ("Ignoring JERRY_INIT_SHOW_REGEXP_OPCODES flag "
+                       "because of !REGEXP_DUMP_BYTE_CODE configuration.\n");
+#endif /* !REGEXP_DUMP_BYTE_CODE */
+  }
+
   JERRY_CONTEXT (jerry_init_flags) = flags;
 
   jerry_make_api_available ();
@@ -182,7 +191,7 @@ jerry_cleanup (void)
 
   jerry_make_api_unavailable ();
   ecma_finalize ();
-  jmem_finalize ((JERRY_CONTEXT (jerry_init_flags) & JERRY_INIT_MEM_STATS) != 0);
+  jmem_finalize ();
 } /* jerry_cleanup */
 
 /**
@@ -271,8 +280,6 @@ jerry_parse (const jerry_char_t *source_p, /**< script source */
 {
   jerry_assert_api_available ();
 
-  parser_set_show_instrs ((JERRY_CONTEXT (jerry_init_flags) & JERRY_INIT_SHOW_OPCODES));
-
   ecma_compiled_code_t *bytecode_data_p;
   ecma_value_t parse_status;
 
diff --git a/jerry-core/jmem/jmem-allocator.c b/jerry-core/jmem/jmem-allocator.c
index 0f7a19d3..ec1343e4 100644
--- a/jerry-core/jmem/jmem-allocator.c
+++ b/jerry-core/jmem/jmem-allocator.c
@@ -40,18 +40,15 @@ jmem_init (void)
  * Finalize memory allocators.
  */
 void
-jmem_finalize (bool is_show_mem_stats) /**< show heap memory stats
-                                            before finalization? */
+jmem_finalize ()
 {
   jmem_pools_finalize ();
 
 #ifdef JMEM_STATS
-  if (is_show_mem_stats)
+  if (JERRY_CONTEXT (jerry_init_flags) & JERRY_INIT_MEM_STATS)
   {
     jmem_stats_print ();
   }
-#else /* !JMEM_STATS */
-  JERRY_UNUSED (is_show_mem_stats);
 #endif /* JMEM_STATS */
 
   jmem_heap_finalize ();
diff --git a/jerry-core/jmem/jmem-allocator.h b/jerry-core/jmem/jmem-allocator.h
index a9fa082b..e7921b86 100644
--- a/jerry-core/jmem/jmem-allocator.h
+++ b/jerry-core/jmem/jmem-allocator.h
@@ -129,7 +129,7 @@ typedef void (*jmem_free_unused_memory_callback_t) (jmem_free_unused_memory_seve
   } while (false);
 
 extern void jmem_init (void);
-extern void jmem_finalize (bool);
+extern void jmem_finalize (void);
 
 extern uintptr_t jmem_compress_pointer (const void *);
 extern void *jmem_decompress_pointer (uintptr_t);
diff --git a/jerry-core/jmem/jmem-heap.c b/jerry-core/jmem/jmem-heap.c
index add89aad..95e98fa8 100644
--- a/jerry-core/jmem/jmem-heap.c
+++ b/jerry-core/jmem/jmem-heap.c
@@ -645,28 +645,27 @@ jmem_heap_stats_print (void)
 {
   jmem_heap_stats_t *heap_stats = &JERRY_CONTEXT (jmem_heap_stats);
 
-  jerry_port_log (JERRY_LOG_LEVEL_DEBUG,
-                  "Heap stats:\n"
-                  "  Heap size = %zu bytes\n"
-                  "  Allocated = %zu bytes\n"
-                  "  Waste = %zu bytes\n"
-                  "  Peak allocated = %zu bytes\n"
-                  "  Peak waste = %zu bytes\n"
-                  "  Skip-ahead ratio = %zu.%04zu\n"
-                  "  Average alloc iteration = %zu.%04zu\n"
-                  "  Average free iteration = %zu.%04zu\n"
-                  "\n",
-                  heap_stats->size,
-                  heap_stats->allocated_bytes,
-                  heap_stats->waste_bytes,
-                  heap_stats->peak_allocated_bytes,
-                  heap_stats->peak_waste_bytes,
-                  heap_stats->skip_count / heap_stats->nonskip_count,
-                  heap_stats->skip_count % heap_stats->nonskip_count * 10000 / heap_stats->nonskip_count,
-                  heap_stats->alloc_iter_count / heap_stats->alloc_count,
-                  heap_stats->alloc_iter_count % heap_stats->alloc_count * 10000 / heap_stats->alloc_count,
-                  heap_stats->free_iter_count / heap_stats->free_count,
-                  heap_stats->free_iter_count % heap_stats->free_count * 10000 / heap_stats->free_count);
+  JERRY_DEBUG_MSG ("Heap stats:\n"
+                   "  Heap size = %zu bytes\n"
+                   "  Allocated = %zu bytes\n"
+                   "  Waste = %zu bytes\n"
+                   "  Peak allocated = %zu bytes\n"
+                   "  Peak waste = %zu bytes\n"
+                   "  Skip-ahead ratio = %zu.%04zu\n"
+                   "  Average alloc iteration = %zu.%04zu\n"
+                   "  Average free iteration = %zu.%04zu\n"
+                   "\n",
+                   heap_stats->size,
+                   heap_stats->allocated_bytes,
+                   heap_stats->waste_bytes,
+                   heap_stats->peak_allocated_bytes,
+                   heap_stats->peak_waste_bytes,
+                   heap_stats->skip_count / heap_stats->nonskip_count,
+                   heap_stats->skip_count % heap_stats->nonskip_count * 10000 / heap_stats->nonskip_count,
+                   heap_stats->alloc_iter_count / heap_stats->alloc_count,
+                   heap_stats->alloc_iter_count % heap_stats->alloc_count * 10000 / heap_stats->alloc_count,
+                   heap_stats->free_iter_count / heap_stats->free_count,
+                   heap_stats->free_iter_count % heap_stats->free_count * 10000 / heap_stats->free_count);
 } /* jmem_heap_stats_print */
 
 /**
diff --git a/jerry-core/jmem/jmem-poolman.c b/jerry-core/jmem/jmem-poolman.c
index 8a1c69eb..0c1ed8c7 100644
--- a/jerry-core/jmem/jmem-poolman.c
+++ b/jerry-core/jmem/jmem-poolman.c
@@ -190,19 +190,18 @@ jmem_pools_stats_print (void)
 {
   jmem_pools_stats_t *pools_stats = &JERRY_CONTEXT (jmem_pools_stats);
 
-  jerry_port_log (JERRY_LOG_LEVEL_DEBUG,
-                  "Pools stats:\n"
-                  "  Chunk size: %zu\n"
-                  "  Pool chunks: %zu\n"
-                  "  Peak pool chunks: %zu\n"
-                  "  Free chunks: %zu\n"
-                  "  Pool reuse ratio: %zu.%04zu\n",
-                  JMEM_POOL_CHUNK_SIZE,
-                  pools_stats->pools_count,
-                  pools_stats->peak_pools_count,
-                  pools_stats->free_chunks,
-                  pools_stats->reused_count / pools_stats->new_alloc_count,
-                  pools_stats->reused_count % pools_stats->new_alloc_count * 10000 / pools_stats->new_alloc_count);
+  JERRY_DEBUG_MSG ("Pools stats:\n"
+                   "  Chunk size: %zu\n"
+                   "  Pool chunks: %zu\n"
+                   "  Peak pool chunks: %zu\n"
+                   "  Free chunks: %zu\n"
+                   "  Pool reuse ratio: %zu.%04zu\n",
+                   JMEM_POOL_CHUNK_SIZE,
+                   pools_stats->pools_count,
+                   pools_stats->peak_pools_count,
+                   pools_stats->free_chunks,
+                   pools_stats->reused_count / pools_stats->new_alloc_count,
+                   pools_stats->reused_count % pools_stats->new_alloc_count * 10000 / pools_stats->new_alloc_count);
 } /* jmem_pools_stats_print */
 
 /**
diff --git a/jerry-core/jrt/jrt-fatals.c b/jerry-core/jrt/jrt-fatals.c
index 8335408c..d523079e 100644
--- a/jerry-core/jrt/jrt-fatals.c
+++ b/jerry-core/jrt/jrt-fatals.c
@@ -38,7 +38,7 @@ jerry_fatal (jerry_fatal_code_t code) /**< status code */
   {
     case ERR_OUT_OF_MEMORY:
     {
-      jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: ERR_OUT_OF_MEMORY\n");
+      JERRY_ERROR_MSG ("Error: ERR_OUT_OF_MEMORY\n");
       break;
     }
     case ERR_SYSCALL:
@@ -48,12 +48,12 @@ jerry_fatal (jerry_fatal_code_t code) /**< status code */
     }
     case ERR_REF_COUNT_LIMIT:
     {
-      jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: ERR_REF_COUNT_LIMIT\n");
+      JERRY_ERROR_MSG ("Error: ERR_REF_COUNT_LIMIT\n");
       break;
     }
     case ERR_FAILED_INTERNAL_ASSERTION:
     {
-      jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: ERR_FAILED_INTERNAL_ASSERTION\n");
+      JERRY_ERROR_MSG ("Error: ERR_FAILED_INTERNAL_ASSERTION\n");
       break;
     }
   }
@@ -77,12 +77,11 @@ jerry_assert_fail (const char *assertion, /**< assertion condition string */
                    const char *function, /**< function name */
                    const uint32_t line) /**< line */
 {
-  jerry_port_log (JERRY_LOG_LEVEL_ERROR,
-                  "ICE: Assertion '%s' failed at %s(%s):%lu.\n",
-                  assertion,
-                  file,
-                  function,
-                  (unsigned long) line);
+  JERRY_ERROR_MSG ("ICE: Assertion '%s' failed at %s(%s):%lu.\n",
+                   assertion,
+                   file,
+                   function,
+                   (unsigned long) line);
 
   jerry_fatal (ERR_FAILED_INTERNAL_ASSERTION);
 } /* jerry_assert_fail */
@@ -95,11 +94,10 @@ jerry_unreachable (const char *file, /**< file name */
                    const char *function, /**< function name */
                    const uint32_t line) /**< line */
 {
-  jerry_port_log (JERRY_LOG_LEVEL_ERROR,
-                  "ICE: Unreachable control path at %s(%s):%lu was executed.\n",
-                  file,
-                  function,
-                  (unsigned long) line);
+  JERRY_ERROR_MSG ("ICE: Unreachable control path at %s(%s):%lu was executed.\n",
+                   file,
+                   function,
+                   (unsigned long) line);
 
   jerry_fatal (ERR_FAILED_INTERNAL_ASSERTION);
 } /* jerry_unreachable */
diff --git a/jerry-core/jrt/jrt.h b/jerry-core/jrt/jrt.h
index fd7cf31e..eb391ad1 100644
--- a/jerry-core/jrt/jrt.h
+++ b/jerry-core/jrt/jrt.h
@@ -119,28 +119,10 @@ extern void __noreturn jerry_fatal (jerry_fatal_code_t);
 /*
  * Logging
  */
-#ifdef JERRY_ENABLE_LOG
-#define JERRY_DLOG(...) jerry_port_log (JERRY_LOG_LEVEL_DEBUG, __VA_ARGS__)
-#define JERRY_DDLOG(...) jerry_port_log (JERRY_LOG_LEVEL_TRACE, __VA_ARGS__)
-#else /* !JERRY_ENABLE_LOG */
-/**
- * Mark for unreachable points and unimplemented cases
- */
-extern void jerry_ref_unused_variables (void *, ...);
-
-#define JERRY_DLOG(...) \
-  do \
-  { \
-    if (false) \
-    { \
-      jerry_ref_unused_variables (0, __VA_ARGS__); \
-    } \
-  } while (0)
-#define JERRY_DDLOG(...) JERRY_DLOG (__VA_ARGS__)
-#endif /* JERRY_ENABLE_LOG */
-
 #define JERRY_ERROR_MSG(...) jerry_port_log (JERRY_LOG_LEVEL_ERROR, __VA_ARGS__)
 #define JERRY_WARNING_MSG(...) jerry_port_log (JERRY_LOG_LEVEL_WARNING, __VA_ARGS__)
+#define JERRY_DEBUG_MSG(...) jerry_port_log (JERRY_LOG_LEVEL_DEBUG, __VA_ARGS__)
+#define JERRY_TRACE_MSG(...) jerry_port_log (JERRY_LOG_LEVEL_TRACE, __VA_ARGS__)
 
 /**
  * Size of struct member
diff --git a/jerry-core/parser/js/common.c b/jerry-core/parser/js/common.c
index e17f056a..0eb2a68e 100644
--- a/jerry-core/parser/js/common.c
+++ b/jerry-core/parser/js/common.c
@@ -59,7 +59,7 @@ util_print_chars (const uint8_t *char_p, /**< character pointer */
 {
   while (size > 0)
   {
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "%c", *char_p++);
+    JERRY_DEBUG_MSG ("%c", *char_p++);
     size--;
   }
 } /* util_print_chars */
@@ -73,7 +73,7 @@ util_print_number (ecma_number_t num_p) /**< number to print */
   lit_utf8_byte_t str_buf[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER];
   lit_utf8_size_t str_size = ecma_number_to_utf8_string (num_p, str_buf, sizeof (str_buf));
   str_buf[str_size] = 0;
-  jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "%s", str_buf);
+  JERRY_DEBUG_MSG ("%s", str_buf);
 } /* util_print_number */
 
 /**
@@ -86,22 +86,22 @@ util_print_literal (lexer_literal_t *literal_p) /**< literal */
   {
     if (literal_p->status_flags & LEXER_FLAG_VAR)
     {
-      jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "var_ident(");
+      JERRY_DEBUG_MSG ("var_ident(");
     }
     else
     {
-      jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "ident(");
+      JERRY_DEBUG_MSG ("ident(");
     }
     util_print_chars (literal_p->u.char_p, literal_p->prop.length);
   }
   else if (literal_p->type == LEXER_FUNCTION_LITERAL)
   {
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "function");
+    JERRY_DEBUG_MSG ("function");
     return;
   }
   else if (literal_p->type == LEXER_STRING_LITERAL)
   {
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "string(");
+    JERRY_DEBUG_MSG ("string(");
     util_print_chars (literal_p->u.char_p, literal_p->prop.length);
   }
   else if (literal_p->type == LEXER_NUMBER_LITERAL)
@@ -110,21 +110,21 @@ util_print_literal (lexer_literal_t *literal_p) /**< literal */
 
     JERRY_ASSERT (ECMA_STRING_GET_CONTAINER (value_p) == ECMA_STRING_LITERAL_NUMBER);
 
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "number(");
+    JERRY_DEBUG_MSG ("number(");
     util_print_number (ecma_get_number_from_value (value_p->u.lit_number));
   }
   else if (literal_p->type == LEXER_REGEXP_LITERAL)
   {
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "regexp");
+    JERRY_DEBUG_MSG ("regexp");
     return;
   }
   else
   {
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "unknown");
+    JERRY_DEBUG_MSG ("unknown");
     return;
   }
 
-  jerry_port_log (JERRY_LOG_LEVEL_DEBUG, ")");
+  JERRY_DEBUG_MSG (")");
 } /* util_print_literal */
 
 #endif /* PARSER_DUMP_BYTE_CODE */
diff --git a/jerry-core/parser/js/common.h b/jerry-core/parser/js/common.h
index f79bd1dd..b597f32a 100644
--- a/jerry-core/parser/js/common.h
+++ b/jerry-core/parser/js/common.h
@@ -33,11 +33,6 @@
  * @{
  */
 
-#ifndef JERRY_NDEBUG
-/* Note: This flag is independent from debug mode. */
-#define PARSER_DUMP_BYTE_CODE
-#endif /* !JERRY_NDEBUG */
-
 #include "ecma-globals.h"
 #include "ecma-regexp-object.h"
 #include "jmem-heap.h"
diff --git a/jerry-core/parser/js/js-parser-statm.c b/jerry-core/parser/js/js-parser-statm.c
index 1e9d3ac9..de44010a 100644
--- a/jerry-core/parser/js/js-parser-statm.c
+++ b/jerry-core/parser/js/js-parser-statm.c
@@ -1609,7 +1609,7 @@ parser_parse_statements (parser_context_t *context_p) /**< context */
     if (context_p->is_show_opcodes
         && switch_to_strict_mode)
     {
-      jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "  Note: switch to strict mode\n\n");
+      JERRY_DEBUG_MSG ("  Note: switch to strict mode\n\n");
     }
 #endif /* PARSER_DUMP_BYTE_CODE */
 
diff --git a/jerry-core/parser/js/js-parser-util.c b/jerry-core/parser/js/js-parser-util.c
index c17ae60e..c3c1b280 100644
--- a/jerry-core/parser/js/js-parser-util.c
+++ b/jerry-core/parser/js/js-parser-util.c
@@ -170,13 +170,13 @@ parser_flush_cbc (parser_context_t *context_p) /**< context */
       name_p = cbc_ext_names[PARSER_GET_EXT_OPCODE (context_p->last_cbc_opcode)];
     }
 
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "  [%3d] %s", (int) context_p->stack_depth, name_p);
+    JERRY_DEBUG_MSG ("  [%3d] %s", (int) context_p->stack_depth, name_p);
 
     if (flags & (CBC_HAS_LITERAL_ARG | CBC_HAS_LITERAL_ARG2))
     {
       uint16_t literal_index = context_p->last_cbc.literal_index;
       lexer_literal_t *literal_p = PARSER_GET_LITERAL (literal_index);
-      jerry_port_log (JERRY_LOG_LEVEL_DEBUG, " idx:%d->", literal_index);
+      JERRY_DEBUG_MSG (" idx:%d->", literal_index);
       util_print_literal (literal_p);
     }
 
@@ -184,7 +184,7 @@ parser_flush_cbc (parser_context_t *context_p) /**< context */
     {
       uint16_t literal_index = context_p->last_cbc.value;
       lexer_literal_t *literal_p = PARSER_GET_LITERAL (literal_index);
-      jerry_port_log (JERRY_LOG_LEVEL_DEBUG, " idx:%d->", literal_index);
+      JERRY_DEBUG_MSG (" idx:%d->", literal_index);
       util_print_literal (literal_p);
 
       if (!(flags & CBC_HAS_LITERAL_ARG))
@@ -192,17 +192,17 @@ parser_flush_cbc (parser_context_t *context_p) /**< context */
         literal_index = context_p->last_cbc.third_literal_index;
 
         lexer_literal_t *literal_p = PARSER_GET_LITERAL (literal_index);
-        jerry_port_log (JERRY_LOG_LEVEL_DEBUG, " idx:%d->", literal_index);
+        JERRY_DEBUG_MSG (" idx:%d->", literal_index);
         util_print_literal (literal_p);
       }
     }
 
     if (flags & CBC_HAS_BYTE_ARG)
     {
-      jerry_port_log (JERRY_LOG_LEVEL_DEBUG, " byte_arg:%d", (int) context_p->last_cbc.value);
+      JERRY_DEBUG_MSG (" byte_arg:%d", (int) context_p->last_cbc.value);
     }
 
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "\n");
+    JERRY_DEBUG_MSG ("\n");
   }
 #endif /* PARSER_DUMP_BYTE_CODE */
 
@@ -327,11 +327,10 @@ parser_emit_cbc_push_number (parser_context_t *context_p, /**< context */
       real_value = -real_value;
     }
 
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG,
-                    "  [%3d] %s number:%d\n",
-                    (int) context_p->stack_depth,
-                    cbc_names[opcode],
-                    real_value);
+    JERRY_DEBUG_MSG ("  [%3d] %s number:%d\n",
+                     (int) context_p->stack_depth,
+                     cbc_names[opcode],
+                     real_value);
   }
 #endif /* PARSER_DUMP_BYTE_CODE */
 
@@ -395,11 +394,11 @@ parser_emit_cbc_forward_branch (parser_context_t *context_p, /**< context */
   {
     if (extra_byte_code_increase == 0)
     {
-      jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "  [%3d] %s\n", (int) context_p->stack_depth, cbc_names[opcode]);
+      JERRY_DEBUG_MSG ("  [%3d] %s\n", (int) context_p->stack_depth, cbc_names[opcode]);
     }
     else
     {
-      jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "  [%3d] %s\n", (int) context_p->stack_depth, cbc_ext_names[opcode]);
+      JERRY_DEBUG_MSG ("  [%3d] %s\n", (int) context_p->stack_depth, cbc_ext_names[opcode]);
     }
   }
 #endif /* PARSER_DUMP_BYTE_CODE */
@@ -510,7 +509,7 @@ parser_emit_cbc_backward_branch (parser_context_t *context_p, /**< context */
 #ifdef PARSER_DUMP_BYTE_CODE
   if (context_p->is_show_opcodes)
   {
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "  [%3d] %s\n", (int) context_p->stack_depth, name);
+    JERRY_DEBUG_MSG ("  [%3d] %s\n", (int) context_p->stack_depth, name);
   }
 #endif /* PARSER_DUMP_BYTE_CODE */
 
diff --git a/jerry-core/parser/js/js-parser.c b/jerry-core/parser/js/js-parser.c
index fae1cca3..c112cbc7 100644
--- a/jerry-core/parser/js/js-parser.c
+++ b/jerry-core/parser/js/js-parser.c
@@ -17,12 +17,9 @@
 #include "ecma-exceptions.h"
 #include "ecma-helpers.h"
 #include "ecma-literal-storage.h"
+#include "jcontext.h"
 #include "js-parser-internal.h"
 
-#ifdef PARSER_DUMP_BYTE_CODE
-static bool parser_show_instrs = false;
-#endif /* PARSER_DUMP_BYTE_CODE */
-
 /** \addtogroup parser Parser
  * @{
  *
@@ -873,35 +870,35 @@ parse_print_literal (ecma_compiled_code_t *compiled_code_p, /**< compiled code *
 
       if (literal_index == const_literal_end)
       {
-        jerry_port_log (JERRY_LOG_LEVEL_DEBUG, " idx:%d(self)->function", literal_index);
+        JERRY_DEBUG_MSG (" idx:%d(self)->function", literal_index);
         break;
       }
 
       JERRY_ASSERT (literal_index < argument_end);
-      jerry_port_log (JERRY_LOG_LEVEL_DEBUG, " idx:%d(arg)->undefined", literal_index);
+      JERRY_DEBUG_MSG (" idx:%d(arg)->undefined", literal_index);
       break;
     }
 
     if (literal_p->prop.index == literal_index
         && literal_p->type != LEXER_UNUSED_LITERAL)
     {
-      jerry_port_log (JERRY_LOG_LEVEL_DEBUG, " idx:%d", literal_index);
+      JERRY_DEBUG_MSG (" idx:%d", literal_index);
 
       if (literal_index < argument_end)
       {
-        jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "(arg)->");
+        JERRY_DEBUG_MSG ("(arg)->");
       }
       else if (literal_index < register_end)
       {
-        jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "(reg)->");
+        JERRY_DEBUG_MSG ("(reg)->");
       }
       else if (literal_index < ident_end)
       {
-        jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "(ident)->");
+        JERRY_DEBUG_MSG ("(ident)->");
       }
       else
       {
-        jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "(lit)->");
+        JERRY_DEBUG_MSG ("(lit)->");
       }
 
       util_print_literal (literal_p);
@@ -946,14 +943,14 @@ parse_print_define_vars (ecma_compiled_code_t *compiled_code_p, /**< compiled co
 
   PARSER_READ_IDENTIFIER_INDEX (identifier_end);
 
-  jerry_port_log (JERRY_LOG_LEVEL_DEBUG, " from: %d to: %d\n", identifier_index, identifier_end);
+  JERRY_DEBUG_MSG (" from: %d to: %d\n", identifier_index, identifier_end);
 
   while (identifier_index <= identifier_end)
   {
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "        ");
+    JERRY_DEBUG_MSG ("        ");
     parse_print_literal (compiled_code_p, identifier_index, literal_pool_p);
     identifier_index++;
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "\n");
+    JERRY_DEBUG_MSG ("\n");
   }
 
   return byte_code_p;
@@ -977,21 +974,21 @@ parse_print_initialize_vars (ecma_compiled_code_t *compiled_code_p, /**< compile
   PARSER_READ_IDENTIFIER_INDEX (identifier_index);
   PARSER_READ_IDENTIFIER_INDEX (identifier_end);
 
-  jerry_port_log (JERRY_LOG_LEVEL_DEBUG, " from: %d to: %d\n", identifier_index, identifier_end);
+  JERRY_DEBUG_MSG (" from: %d to: %d\n", identifier_index, identifier_end);
 
   while (identifier_index <= identifier_end)
   {
     uint16_t literal_index;
 
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "        ");
+    JERRY_DEBUG_MSG ("        ");
     parse_print_literal (compiled_code_p, identifier_index, literal_pool_p);
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, " =");
+    JERRY_DEBUG_MSG (" =");
 
     PARSER_READ_IDENTIFIER_INDEX (literal_index);
 
     parse_print_literal (compiled_code_p, literal_index, literal_pool_p);
     identifier_index++;
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "\n");
+    JERRY_DEBUG_MSG ("\n");
   }
 
   return byte_code_p;
@@ -1039,50 +1036,49 @@ parse_print_final_cbc (ecma_compiled_code_t *compiled_code_p, /**< compiled code
     literal_end = args->literal_end;
   }
 
-  jerry_port_log (JERRY_LOG_LEVEL_DEBUG,
-                  "\nFinal byte code dump:\n\n  Maximum stack depth: %d\n  Flags: [",
-                  (int) stack_limit);
+  JERRY_DEBUG_MSG ("\nFinal byte code dump:\n\n  Maximum stack depth: %d\n  Flags: [",
+                   (int) stack_limit);
 
   if (!(compiled_code_p->status_flags & CBC_CODE_FLAGS_FULL_LITERAL_ENCODING))
   {
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "small_lit_enc");
+    JERRY_DEBUG_MSG ("small_lit_enc");
     encoding_limit = 255;
     encoding_delta = 0xfe01;
   }
   else
   {
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "full_lit_enc");
+    JERRY_DEBUG_MSG ("full_lit_enc");
     encoding_limit = 128;
     encoding_delta = 0x8000;
   }
 
   if (compiled_code_p->status_flags & CBC_CODE_FLAGS_UINT16_ARGUMENTS)
   {
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, ",uint16_arguments");
+    JERRY_DEBUG_MSG (",uint16_arguments");
   }
 
   if (compiled_code_p->status_flags & CBC_CODE_FLAGS_STRICT_MODE)
   {
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, ",strict_mode");
+    JERRY_DEBUG_MSG (",strict_mode");
   }
 
   if (compiled_code_p->status_flags & CBC_CODE_FLAGS_ARGUMENTS_NEEDED)
   {
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, ",arguments_needed");
+    JERRY_DEBUG_MSG (",arguments_needed");
   }
 
   if (compiled_code_p->status_flags & CBC_CODE_FLAGS_LEXICAL_ENV_NOT_NEEDED)
   {
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, ",no_lexical_env");
+    JERRY_DEBUG_MSG (",no_lexical_env");
   }
 
-  jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "]\n");
+  JERRY_DEBUG_MSG ("]\n");
 
-  jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "  Argument range end: %d\n", (int) argument_end);
-  jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "  Register range end: %d\n", (int) register_end);
-  jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "  Identifier range end: %d\n", (int) ident_end);
-  jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "  Const literal range end: %d\n", (int) const_literal_end);
-  jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "  Literal range end: %d\n\n", (int) literal_end);
+  JERRY_DEBUG_MSG ("  Argument range end: %d\n", (int) argument_end);
+  JERRY_DEBUG_MSG ("  Register range end: %d\n", (int) register_end);
+  JERRY_DEBUG_MSG ("  Identifier range end: %d\n", (int) ident_end);
+  JERRY_DEBUG_MSG ("  Const literal range end: %d\n", (int) const_literal_end);
+  JERRY_DEBUG_MSG ("  Literal range end: %d\n\n", (int) literal_end);
 
   byte_code_start_p = (uint8_t *) compiled_code_p;
 
@@ -1112,7 +1108,7 @@ parse_print_final_cbc (ecma_compiled_code_t *compiled_code_p, /**< compiled code
     if (opcode != CBC_EXT_OPCODE)
     {
       flags = cbc_flags[opcode];
-      jerry_port_log (JERRY_LOG_LEVEL_DEBUG, " %3d : %s", (int) cbc_offset, cbc_names[opcode]);
+      JERRY_DEBUG_MSG (" %3d : %s", (int) cbc_offset, cbc_names[opcode]);
       byte_code_p++;
 
       if (opcode == CBC_INITIALIZE_VARS)
@@ -1138,14 +1134,14 @@ parse_print_final_cbc (ecma_compiled_code_t *compiled_code_p, /**< compiled code
       if (opcode == CBC_PUSH_NUMBER_POS_BYTE)
       {
         int value = *byte_code_p++;
-        jerry_port_log (JERRY_LOG_LEVEL_DEBUG, " number:%d\n", value + 1);
+        JERRY_DEBUG_MSG (" number:%d\n", value + 1);
         continue;
       }
 
       if (opcode == CBC_PUSH_NUMBER_NEG_BYTE)
       {
         int value = *byte_code_p++;
-        jerry_port_log (JERRY_LOG_LEVEL_DEBUG, " number:%d\n", -(value + 1));
+        JERRY_DEBUG_MSG (" number:%d\n", -(value + 1));
         continue;
       }
     }
@@ -1153,7 +1149,7 @@ parse_print_final_cbc (ecma_compiled_code_t *compiled_code_p, /**< compiled code
     {
       ext_opcode = (cbc_ext_opcode_t) byte_code_p[1];
       flags = cbc_ext_flags[ext_opcode];
-      jerry_port_log (JERRY_LOG_LEVEL_DEBUG, " %3d : %s", (int) cbc_offset, cbc_ext_names[ext_opcode]);
+      JERRY_DEBUG_MSG (" %3d : %s", (int) cbc_offset, cbc_ext_names[ext_opcode]);
       byte_code_p += 2;
     }
 
@@ -1181,7 +1177,7 @@ parse_print_final_cbc (ecma_compiled_code_t *compiled_code_p, /**< compiled code
 
     if (flags & CBC_HAS_BYTE_ARG)
     {
-      jerry_port_log (JERRY_LOG_LEVEL_DEBUG, " byte_arg:%d", *byte_code_p);
+      JERRY_DEBUG_MSG (" byte_arg:%d", *byte_code_p);
       byte_code_p++;
     }
 
@@ -1203,15 +1199,15 @@ parse_print_final_cbc (ecma_compiled_code_t *compiled_code_p, /**< compiled code
 
       if (CBC_BRANCH_IS_FORWARD (flags))
       {
-        jerry_port_log (JERRY_LOG_LEVEL_DEBUG, " offset:%d(->%d)", (int) offset, (int) (cbc_offset + offset));
+        JERRY_DEBUG_MSG (" offset:%d(->%d)", (int) offset, (int) (cbc_offset + offset));
       }
       else
       {
-        jerry_port_log (JERRY_LOG_LEVEL_DEBUG, " offset:%d(->%d)", (int) offset, (int) (cbc_offset - offset));
+        JERRY_DEBUG_MSG (" offset:%d(->%d)", (int) offset, (int) (cbc_offset - offset));
       }
     }
 
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "\n");
+    JERRY_DEBUG_MSG ("\n");
   }
 } /* parse_print_final_cbc */
 
@@ -1688,7 +1684,7 @@ parser_post_processing (parser_context_t *context_p) /**< context */
     lexer_literal_t *literal_p;
 
     parse_print_final_cbc (compiled_code_p, &context_p->literal_pool, length);
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "\nByte code size: %d bytes\n", (int) length);
+    JERRY_DEBUG_MSG ("\nByte code size: %d bytes\n", (int) length);
     context_p->total_byte_code_size += (uint32_t) length;
 
     parser_list_iterator_init (&context_p->literal_pool, &literal_iterator);
@@ -1854,12 +1850,12 @@ parser_parse_source (const uint8_t *source_p, /**< valid UTF-8 source code */
 #endif /* !JERRY_NDEBUG */
 
 #ifdef PARSER_DUMP_BYTE_CODE
-  context.is_show_opcodes = parser_show_instrs;
+  context.is_show_opcodes = (JERRY_CONTEXT (jerry_init_flags) & JERRY_INIT_SHOW_OPCODES);
   context.total_byte_code_size = 0;
 
   if (context.is_show_opcodes)
   {
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "\n--- Script parsing start ---\n\n");
+    JERRY_DEBUG_MSG ("\n--- Script parsing start ---\n\n");
   }
 #endif /* PARSER_DUMP_BYTE_CODE */
 
@@ -1893,9 +1889,8 @@ parser_parse_source (const uint8_t *source_p, /**< valid UTF-8 source code */
 #ifdef PARSER_DUMP_BYTE_CODE
     if (context.is_show_opcodes)
     {
-      jerry_port_log (JERRY_LOG_LEVEL_DEBUG,
-                      "\nScript parsing successfully completed. Total byte code size: %d bytes\n",
-                      (int) context.total_byte_code_size);
+      JERRY_DEBUG_MSG ("\nScript parsing successfully completed. Total byte code size: %d bytes\n",
+                       (int) context.total_byte_code_size);
     }
 #endif /* PARSER_DUMP_BYTE_CODE */
   }
@@ -1928,7 +1923,7 @@ parser_parse_source (const uint8_t *source_p, /**< valid UTF-8 source code */
 #ifdef PARSER_DUMP_BYTE_CODE
   if (context.is_show_opcodes)
   {
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "\n--- Script parsing end ---\n\n");
+    JERRY_DEBUG_MSG ("\n--- Script parsing end ---\n\n");
   }
 #endif /* PARSER_DUMP_BYTE_CODE */
 
@@ -1997,7 +1992,7 @@ parser_parse_function (parser_context_t *context_p, /**< context */
 #ifdef PARSER_DUMP_BYTE_CODE
   if (context_p->is_show_opcodes)
   {
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "\n--- Function parsing start ---\n\n");
+    JERRY_DEBUG_MSG ("\n--- Function parsing start ---\n\n");
   }
 #endif /* PARSER_DUMP_BYTE_CODE */
 
@@ -2144,7 +2139,7 @@ parser_parse_function (parser_context_t *context_p, /**< context */
   if (context_p->is_show_opcodes
       && (context_p->status_flags & PARSER_HAS_NON_STRICT_ARG))
   {
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "  Note: legacy (non-strict) argument definition\n\n");
+    JERRY_DEBUG_MSG ("  Note: legacy (non-strict) argument definition\n\n");
   }
 #endif /* PARSER_DUMP_BYTE_CODE */
 
@@ -2160,7 +2155,7 @@ parser_parse_function (parser_context_t *context_p, /**< context */
 #ifdef PARSER_DUMP_BYTE_CODE
   if (context_p->is_show_opcodes)
   {
-    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "\n--- Function parsing end ---\n\n");
+    JERRY_DEBUG_MSG ("\n--- Function parsing end ---\n\n");
   }
 #endif /* PARSER_DUMP_BYTE_CODE */
 
@@ -2227,19 +2222,6 @@ parser_raise_error (parser_context_t *context_p, /**< context */
 } /* parser_raise_error */
 
 /**
- * Tell parser whether to dump bytecode
- */
-void
-parser_set_show_instrs (int show_instrs) /**< flag indicating whether to dump bytecode */
-{
-#ifdef PARSER_DUMP_BYTE_CODE
-  parser_show_instrs = show_instrs;
-#else /* !PARSER_DUMP_BYTE_CODE */
-  JERRY_UNUSED (show_instrs);
-#endif /* PARSER_DUMP_BYTE_CODE */
-} /* parser_set_show_instrs */
-
-/**
  * Parse EcamScript source code
  *
  * Note:
diff --git a/jerry-core/parser/js/js-parser.h b/jerry-core/parser/js/js-parser.h
index f7b481ba..aa63d1f3 100644
--- a/jerry-core/parser/js/js-parser.h
+++ b/jerry-core/parser/js/js-parser.h
@@ -133,8 +133,6 @@ extern ecma_value_t parser_parse_script (const uint8_t *, size_t, bool, ecma_com
 
 const char *parser_error_to_string (parser_error_t);
 
-extern void parser_set_show_instrs (int);
-
 /**
  * @}
  * @}
diff --git a/jerry-core/parser/regexp/re-bytecode.c b/jerry-core/parser/regexp/re-bytecode.c
index 4a4bf96c..596c2b58 100644
--- a/jerry-core/parser/regexp/re-bytecode.c
+++ b/jerry-core/parser/regexp/re-bytecode.c
@@ -232,7 +232,7 @@ re_insert_u32 (re_bytecode_ctx_t *bc_ctx_p, /**< RegExp bytecode context */
   re_bytecode_list_insert (bc_ctx_p, offset, (uint8_t *) &value, sizeof (uint32_t));
 } /* re_insert_u32 */
 
-#ifdef JERRY_ENABLE_LOG
+#ifdef REGEXP_DUMP_BYTE_CODE
 /**
  * RegExp bytecode dumper
  */
@@ -240,9 +240,9 @@ void
 re_dump_bytecode (re_bytecode_ctx_t *bc_ctx_p) /**< RegExp bytecode context */
 {
   re_compiled_code_t *compiled_code_p = (re_compiled_code_t *) bc_ctx_p->block_start_p;
-  JERRY_DLOG ("%d ", compiled_code_p->header.status_flags);
-  JERRY_DLOG ("%d ", compiled_code_p->num_of_captures);
-  JERRY_DLOG ("%d | ", compiled_code_p->num_of_non_captures);
+  JERRY_DEBUG_MSG ("%d ", compiled_code_p->header.status_flags);
+  JERRY_DEBUG_MSG ("%d ", compiled_code_p->num_of_captures);
+  JERRY_DEBUG_MSG ("%d | ", compiled_code_p->num_of_non_captures);
 
   uint8_t *bytecode_p = (uint8_t *) (compiled_code_p + 1);
 
@@ -253,188 +253,188 @@ re_dump_bytecode (re_bytecode_ctx_t *bc_ctx_p) /**< RegExp bytecode context */
     {
       case RE_OP_MATCH:
       {
-        JERRY_DLOG ("MATCH, ");
+        JERRY_DEBUG_MSG ("MATCH, ");
         break;
       }
       case RE_OP_CHAR:
       {
-        JERRY_DLOG ("CHAR ");
-        JERRY_DLOG ("%c, ", (char) re_get_char (&bytecode_p));
+        JERRY_DEBUG_MSG ("CHAR ");
+        JERRY_DEBUG_MSG ("%c, ", (char) re_get_char (&bytecode_p));
         break;
       }
       case RE_OP_CAPTURE_NON_GREEDY_ZERO_GROUP_START:
       {
-        JERRY_DLOG ("N");
+        JERRY_DEBUG_MSG ("N");
         /* FALLTHRU */
       }
       case RE_OP_CAPTURE_GREEDY_ZERO_GROUP_START:
       {
-        JERRY_DLOG ("GZ_START ");
-        JERRY_DLOG ("%d ", re_get_value (&bytecode_p));
-        JERRY_DLOG ("%d ", re_get_value (&bytecode_p));
-        JERRY_DLOG ("%d, ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("GZ_START ");
+        JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
         break;
       }
       case RE_OP_CAPTURE_GROUP_START:
       {
-        JERRY_DLOG ("START ");
-        JERRY_DLOG ("%d ", re_get_value (&bytecode_p));
-        JERRY_DLOG ("%d, ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("START ");
+        JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
         break;
       }
       case RE_OP_CAPTURE_NON_GREEDY_GROUP_END:
       {
-        JERRY_DLOG ("N");
+        JERRY_DEBUG_MSG ("N");
         /* FALLTHRU */
       }
       case RE_OP_CAPTURE_GREEDY_GROUP_END:
       {
-        JERRY_DLOG ("G_END ");
-        JERRY_DLOG ("%d ", re_get_value (&bytecode_p));
-        JERRY_DLOG ("%d ", re_get_value (&bytecode_p));
-        JERRY_DLOG ("%d ", re_get_value (&bytecode_p));
-        JERRY_DLOG ("%d, ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("G_END ");
+        JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
         break;
       }
       case RE_OP_NON_CAPTURE_NON_GREEDY_ZERO_GROUP_START:
       {
-        JERRY_DLOG ("N");
+        JERRY_DEBUG_MSG ("N");
         /* FALLTHRU */
       }
       case RE_OP_NON_CAPTURE_GREEDY_ZERO_GROUP_START:
       {
-        JERRY_DLOG ("GZ_NC_START ");
-        JERRY_DLOG ("%d ", re_get_value (&bytecode_p));
-        JERRY_DLOG ("%d ", re_get_value (&bytecode_p));
-        JERRY_DLOG ("%d, ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("GZ_NC_START ");
+        JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
         break;
       }
       case RE_OP_NON_CAPTURE_GROUP_START:
       {
-        JERRY_DLOG ("NC_START ");
-        JERRY_DLOG ("%d ", re_get_value (&bytecode_p));
-        JERRY_DLOG ("%d, ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("NC_START ");
+        JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
         break;
       }
       case RE_OP_NON_CAPTURE_NON_GREEDY_GROUP_END:
       {
-        JERRY_DLOG ("N");
+        JERRY_DEBUG_MSG ("N");
         /* FALLTHRU */
       }
       case RE_OP_NON_CAPTURE_GREEDY_GROUP_END:
       {
-        JERRY_DLOG ("G_NC_END ");
-        JERRY_DLOG ("%d ", re_get_value (&bytecode_p));
-        JERRY_DLOG ("%d ", re_get_value (&bytecode_p));
-        JERRY_DLOG ("%d ", re_get_value (&bytecode_p));
-        JERRY_DLOG ("%d, ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("G_NC_END ");
+        JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
         break;
       }
       case RE_OP_SAVE_AT_START:
       {
-        JERRY_DLOG ("RE_START ");
-        JERRY_DLOG ("%d, ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("RE_START ");
+        JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
         break;
       }
       case RE_OP_SAVE_AND_MATCH:
       {
-        JERRY_DLOG ("RE_END, ");
+        JERRY_DEBUG_MSG ("RE_END, ");
         break;
       }
       case RE_OP_GREEDY_ITERATOR:
       {
-        JERRY_DLOG ("GREEDY_ITERATOR ");
-        JERRY_DLOG ("%d ", re_get_value (&bytecode_p));
-        JERRY_DLOG ("%d ", re_get_value (&bytecode_p));
-        JERRY_DLOG ("%d, ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("GREEDY_ITERATOR ");
+        JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
         break;
       }
       case RE_OP_NON_GREEDY_ITERATOR:
       {
-        JERRY_DLOG ("NON_GREEDY_ITERATOR ");
-        JERRY_DLOG ("%d, ", re_get_value (&bytecode_p));
-        JERRY_DLOG ("%d, ", re_get_value (&bytecode_p));
-        JERRY_DLOG ("%d, ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("NON_GREEDY_ITERATOR ");
+        JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
         break;
       }
       case RE_OP_PERIOD:
       {
-        JERRY_DLOG ("PERIOD ");
+        JERRY_DEBUG_MSG ("PERIOD ");
         break;
       }
       case RE_OP_ALTERNATIVE:
       {
-        JERRY_DLOG ("ALTERNATIVE ");
-        JERRY_DLOG ("%d, ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("ALTERNATIVE ");
+        JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
         break;
       }
       case RE_OP_ASSERT_START:
       {
-        JERRY_DLOG ("ASSERT_START ");
+        JERRY_DEBUG_MSG ("ASSERT_START ");
         break;
       }
       case RE_OP_ASSERT_END:
       {
-        JERRY_DLOG ("ASSERT_END ");
+        JERRY_DEBUG_MSG ("ASSERT_END ");
         break;
       }
       case RE_OP_ASSERT_WORD_BOUNDARY:
       {
-        JERRY_DLOG ("ASSERT_WORD_BOUNDARY ");
+        JERRY_DEBUG_MSG ("ASSERT_WORD_BOUNDARY ");
         break;
       }
       case RE_OP_ASSERT_NOT_WORD_BOUNDARY:
       {
-        JERRY_DLOG ("ASSERT_NOT_WORD_BOUNDARY ");
+        JERRY_DEBUG_MSG ("ASSERT_NOT_WORD_BOUNDARY ");
         break;
       }
       case RE_OP_LOOKAHEAD_POS:
       {
-        JERRY_DLOG ("LOOKAHEAD_POS ");
-        JERRY_DLOG ("%d, ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("LOOKAHEAD_POS ");
+        JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
         break;
       }
       case RE_OP_LOOKAHEAD_NEG:
       {
-        JERRY_DLOG ("LOOKAHEAD_NEG ");
-        JERRY_DLOG ("%d, ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("LOOKAHEAD_NEG ");
+        JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
         break;
       }
       case RE_OP_BACKREFERENCE:
       {
-        JERRY_DLOG ("BACKREFERENCE ");
-        JERRY_DLOG ("%d, ", re_get_value (&bytecode_p));
+        JERRY_DEBUG_MSG ("BACKREFERENCE ");
+        JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
         break;
       }
       case RE_OP_INV_CHAR_CLASS:
       {
-        JERRY_DLOG ("INV_");
+        JERRY_DEBUG_MSG ("INV_");
         /* FALLTHRU */
       }
       case RE_OP_CHAR_CLASS:
       {
-        JERRY_DLOG ("CHAR_CLASS ");
+        JERRY_DEBUG_MSG ("CHAR_CLASS ");
         uint32_t num_of_class = re_get_value (&bytecode_p);
-        JERRY_DLOG ("%d", num_of_class);
+        JERRY_DEBUG_MSG ("%d", num_of_class);
         while (num_of_class)
         {
-          JERRY_DLOG (" %d", re_get_char (&bytecode_p));
-          JERRY_DLOG ("-%d", re_get_char (&bytecode_p));
+          JERRY_DEBUG_MSG (" %d", re_get_char (&bytecode_p));
+          JERRY_DEBUG_MSG ("-%d", re_get_char (&bytecode_p));
           num_of_class--;
         }
-        JERRY_DLOG (", ");
+        JERRY_DEBUG_MSG (", ");
         break;
       }
       default:
       {
-        JERRY_DLOG ("UNKNOWN(%d), ", (uint32_t) op);
+        JERRY_DEBUG_MSG ("UNKNOWN(%d), ", (uint32_t) op);
         break;
       }
     }
   }
-  JERRY_DLOG ("EOF\n");
+  JERRY_DEBUG_MSG ("EOF\n");
 } /* re_dump_bytecode */
-#endif /* JERRY_ENABLE_LOG */
+#endif /* REGEXP_DUMP_BYTE_CODE */
 
 /**
  * @}
diff --git a/jerry-core/parser/regexp/re-bytecode.h b/jerry-core/parser/regexp/re-bytecode.h
index 91c4bce8..d2bdb736 100644
--- a/jerry-core/parser/regexp/re-bytecode.h
+++ b/jerry-core/parser/regexp/re-bytecode.h
@@ -115,9 +115,9 @@ void re_insert_opcode (re_bytecode_ctx_t *, uint32_t, re_opcode_t);
 void re_insert_u32 (re_bytecode_ctx_t *, uint32_t, uint32_t);
 void re_bytecode_list_insert (re_bytecode_ctx_t *, size_t, uint8_t *, size_t);
 
-#ifdef JERRY_ENABLE_LOG
+#ifdef REGEXP_DUMP_BYTE_CODE
 void re_dump_bytecode (re_bytecode_ctx_t *bc_ctx);
-#endif /* JERRY_ENABLE_LOG */
+#endif /* REGEXP_DUMP_BYTE_CODE */
 
 /**
  * @}
diff --git a/jerry-core/parser/regexp/re-compiler.c b/jerry-core/parser/regexp/re-compiler.c
index ab01c014..47556837 100644
--- a/jerry-core/parser/regexp/re-compiler.c
+++ b/jerry-core/parser/regexp/re-compiler.c
@@ -237,7 +237,7 @@ re_parse_alternative (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context
       case RE_TOK_START_CAPTURE_GROUP:
       {
         idx = re_ctx_p->num_of_captures++;
-        JERRY_DDLOG ("Compile a capture group start (idx: %d)\n", idx);
+        JERRY_TRACE_MSG ("Compile a capture group start (idx: %d)\n", idx);
 
         ret_value = re_parse_alternative (re_ctx_p, false);
 
@@ -251,7 +251,7 @@ re_parse_alternative (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context
       case RE_TOK_START_NON_CAPTURE_GROUP:
       {
         idx = re_ctx_p->num_of_non_captures++;
-        JERRY_DDLOG ("Compile a non-capture group start (idx: %d)\n", idx);
+        JERRY_TRACE_MSG ("Compile a non-capture group start (idx: %d)\n", idx);
 
         ret_value = re_parse_alternative (re_ctx_p, false);
 
@@ -264,8 +264,8 @@ re_parse_alternative (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context
       }
       case RE_TOK_CHAR:
       {
-        JERRY_DDLOG ("Compile character token: %c, qmin: %d, qmax: %d\n",
-                     re_ctx_p->current_token.value, re_ctx_p->current_token.qmin, re_ctx_p->current_token.qmax);
+        JERRY_TRACE_MSG ("Compile character token: %c, qmin: %d, qmax: %d\n",
+                         re_ctx_p->current_token.value, re_ctx_p->current_token.qmin, re_ctx_p->current_token.qmax);
 
         re_append_opcode (bc_ctx_p, RE_OP_CHAR);
         re_append_char (bc_ctx_p, re_canonicalize ((ecma_char_t) re_ctx_p->current_token.value,
@@ -279,7 +279,7 @@ re_parse_alternative (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context
       }
       case RE_TOK_PERIOD:
       {
-        JERRY_DDLOG ("Compile a period\n");
+        JERRY_TRACE_MSG ("Compile a period\n");
         re_append_opcode (bc_ctx_p, RE_OP_PERIOD);
 
         if ((re_ctx_p->current_token.qmin != 1) || (re_ctx_p->current_token.qmax != 1))
@@ -290,7 +290,7 @@ re_parse_alternative (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context
       }
       case RE_TOK_ALTERNATIVE:
       {
-        JERRY_DDLOG ("Compile an alternative\n");
+        JERRY_TRACE_MSG ("Compile an alternative\n");
         re_insert_u32 (bc_ctx_p, alterantive_offset, re_get_bytecode_length (bc_ctx_p) - alterantive_offset);
         re_append_opcode (bc_ctx_p, RE_OP_ALTERNATIVE);
         alterantive_offset = re_get_bytecode_length (re_ctx_p->bytecode_ctx_p);
@@ -298,31 +298,31 @@ re_parse_alternative (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context
       }
       case RE_TOK_ASSERT_START:
       {
-        JERRY_DDLOG ("Compile a start assertion\n");
+        JERRY_TRACE_MSG ("Compile a start assertion\n");
         re_append_opcode (bc_ctx_p, RE_OP_ASSERT_START);
         break;
       }
       case RE_TOK_ASSERT_END:
       {
-        JERRY_DDLOG ("Compile an end assertion\n");
+        JERRY_TRACE_MSG ("Compile an end assertion\n");
         re_append_opcode (bc_ctx_p, RE_OP_ASSERT_END);
         break;
       }
       case RE_TOK_ASSERT_WORD_BOUNDARY:
       {
-        JERRY_DDLOG ("Compile a word boundary assertion\n");
+        JERRY_TRACE_MSG ("Compile a word boundary assertion\n");
         re_append_opcode (bc_ctx_p, RE_OP_ASSERT_WORD_BOUNDARY);
         break;
       }
       case RE_TOK_ASSERT_NOT_WORD_BOUNDARY:
       {
-        JERRY_DDLOG ("Compile a not word boundary assertion\n");
+        JERRY_TRACE_MSG ("Compile a not word boundary assertion\n");
         re_append_opcode (bc_ctx_p, RE_OP_ASSERT_NOT_WORD_BOUNDARY);
         break;
       }
       case RE_TOK_ASSERT_START_POS_LOOKAHEAD:
       {
-        JERRY_DDLOG ("Compile a positive lookahead assertion\n");
+        JERRY_TRACE_MSG ("Compile a positive lookahead assertion\n");
         idx = re_ctx_p->num_of_non_captures++;
         re_append_opcode (bc_ctx_p, RE_OP_LOOKAHEAD_POS);
 
@@ -339,7 +339,7 @@ re_parse_alternative (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context
       }
       case RE_TOK_ASSERT_START_NEG_LOOKAHEAD:
       {
-        JERRY_DDLOG ("Compile a negative lookahead assertion\n");
+        JERRY_TRACE_MSG ("Compile a negative lookahead assertion\n");
         idx = re_ctx_p->num_of_non_captures++;
         re_append_opcode (bc_ctx_p, RE_OP_LOOKAHEAD_NEG);
 
@@ -364,7 +364,7 @@ re_parse_alternative (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context
           re_ctx_p->highest_backref = backref;
         }
 
-        JERRY_DDLOG ("Compile a backreference: %d\n", backref);
+        JERRY_TRACE_MSG ("Compile a backreference: %d\n", backref);
         re_append_opcode (bc_ctx_p, RE_OP_BACKREFERENCE);
         re_append_u32 (bc_ctx_p, backref);
 
@@ -380,7 +380,7 @@ re_parse_alternative (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context
       case RE_TOK_START_CHAR_CLASS:
       case RE_TOK_START_INV_CHAR_CLASS:
       {
-        JERRY_DDLOG ("Compile a character class\n");
+        JERRY_TRACE_MSG ("Compile a character class\n");
         re_append_opcode (bc_ctx_p,
                           re_ctx_p->current_token.type == RE_TOK_START_INV_CHAR_CLASS
                                                        ? RE_OP_INV_CHAR_CLASS
@@ -406,7 +406,7 @@ re_parse_alternative (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context
       }
       case RE_TOK_END_GROUP:
       {
-        JERRY_DDLOG ("Compile a group end\n");
+        JERRY_TRACE_MSG ("Compile a group end\n");
 
         if (expect_eof)
         {
@@ -469,7 +469,7 @@ re_find_bytecode_in_cache (ecma_string_t *pattern_str_p, /**< pattern string */
       if ((cached_bytecode_p->header.status_flags & RE_FLAGS_MASK) == flags
           && ecma_compare_ecma_strings (cached_pattern_str_p, pattern_str_p))
       {
-        JERRY_DDLOG ("RegExp is found in cache\n");
+        JERRY_TRACE_MSG ("RegExp is found in cache\n");
         return idx;
       }
     }
@@ -480,7 +480,7 @@ re_find_bytecode_in_cache (ecma_string_t *pattern_str_p, /**< pattern string */
     }
   }
 
-  JERRY_DDLOG ("RegExp is NOT found in cache\n");
+  JERRY_TRACE_MSG ("RegExp is NOT found in cache\n");
   return free_idx;
 } /* re_find_bytecode_in_cache */
 
@@ -594,15 +594,18 @@ re_compile_bytecode (const re_compiled_code_t **out_bytecode_p, /**< [out] point
   if (!ecma_is_value_empty (ret_value))
   {
     /* Compilation failed, free bytecode. */
-    JERRY_DDLOG ("RegExp compilation failed!\n");
+    JERRY_TRACE_MSG ("RegExp compilation failed!\n");
     jmem_heap_free_block (bc_ctx.block_start_p, byte_code_size);
     *out_bytecode_p = NULL;
   }
   else
   {
-#ifdef JERRY_ENABLE_LOG
-    re_dump_bytecode (&bc_ctx);
-#endif /* JERRY_ENABLE_LOG */
+#ifdef REGEXP_DUMP_BYTE_CODE
+    if (JERRY_CONTEXT (jerry_init_flags) & JERRY_INIT_SHOW_REGEXP_OPCODES)
+    {
+      re_dump_bytecode (&bc_ctx);
+    }
+#endif /* REGEXP_DUMP_BYTE_CODE */
 
     /* The RegExp bytecode contains at least a RE_OP_SAVE_AT_START opdoce, so it cannot be NULL. */
     JERRY_ASSERT (bc_ctx.block_start_p != NULL);
@@ -617,7 +620,7 @@ re_compile_bytecode (const re_compiled_code_t **out_bytecode_p, /**< [out] point
         JERRY_CONTEXT (re_cache_idx) = 0;
       }
 
-      JERRY_DDLOG ("RegExp cache is full! Remove the element on idx: %d\n", JERRY_CONTEXT (re_cache_idx));
+      JERRY_TRACE_MSG ("RegExp cache is full! Remove the element on idx: %d\n", JERRY_CONTEXT (re_cache_idx));
 
       cache_idx = JERRY_CONTEXT (re_cache_idx)++;
 
@@ -629,7 +632,7 @@ re_compile_bytecode (const re_compiled_code_t **out_bytecode_p, /**< [out] point
       }
     }
 
-    JERRY_DDLOG ("Insert bytecode into RegExp cache (idx: %d).\n", cache_idx);
+    JERRY_TRACE_MSG ("Insert bytecode into RegExp cache (idx: %d).\n", cache_idx);
     ecma_bytecode_ref ((ecma_compiled_code_t *) *out_bytecode_p);
     JERRY_CONTEXT (re_cache)[cache_idx] = *out_bytecode_p;
   }
diff --git a/jerry-main/main-unix.c b/jerry-main/main-unix.c
index 4f53aaf2..c83aea57 100644
--- a/jerry-main/main-unix.c
+++ b/jerry-main/main-unix.c
@@ -111,6 +111,7 @@ print_help (char *name)
                       "  --mem-stats-separate\n"
                       "  --parse-only\n"
                       "  --show-opcodes\n"
+                      "  --show-regexp-opcodes\n"
                       "  --save-snapshot-for-global FILE\n"
                       "  --save-snapshot-for-eval FILE\n"
                       "  --exec-snapshot FILE\n"
@@ -187,6 +188,11 @@ main (int argc,
       flags |= JERRY_INIT_SHOW_OPCODES;
       jerry_port_default_set_log_level (JERRY_LOG_LEVEL_DEBUG);
     }
+    else if (!strcmp ("--show-regexp-opcodes", argv[i]))
+    {
+      flags |= JERRY_INIT_SHOW_REGEXP_OPCODES;
+      jerry_port_default_set_log_level (JERRY_LOG_LEVEL_DEBUG);
+    }
     else if (!strcmp ("--save-snapshot-for-global", argv[i])
              || !strcmp ("--save-snapshot-for-eval", argv[i]))
     {
@@ -237,10 +243,7 @@ main (int argc,
         return JERRY_STANDALONE_EXIT_CODE_FAIL;
       }
 
-#ifdef JERRY_ENABLE_LOG
-      flags |= JERRY_INIT_ENABLE_LOG;
       jerry_port_default_set_log_level (argv[i][0] - '0');
-#endif /* JERRY_ENABLE_LOG */
     }
     else if (!strcmp ("--abort-on-fail", argv[i]))
     {
diff --git a/targets/nuttx-stm32f4/main-nuttx.c b/targets/nuttx-stm32f4/main-nuttx.c
index ae0f74c3..2327b831 100644
--- a/targets/nuttx-stm32f4/main-nuttx.c
+++ b/targets/nuttx-stm32f4/main-nuttx.c
@@ -209,9 +209,7 @@ int jerryscript_entry (int argc, char *argv[])
       flags |= JERRY_FLAG_ENABLE_LOG;
       if (++i < argc && strlen (argv[i]) == 1 && argv[i][0] >='0' && argv[i][0] <= '3')
       {
-#ifdef JERRY_ENABLE_LOG
         jerry_debug_level = argv[i][0] - '0';
-#endif /* JERRY_ENABLE_LOG */
       }
       else
       {
diff --git a/tests/unit/test-lit-char-helpers.c b/tests/unit/test-lit-char-helpers.c
index fd8863e5..18483988 100644
--- a/tests/unit/test-lit-char-helpers.c
+++ b/tests/unit/test-lit-char-helpers.c
@@ -74,7 +74,7 @@ main ()
   TEST_ASSERT (length == 3);
 
   ecma_finalize ();
-  jmem_finalize (true);
+  jmem_finalize ();
 
   return 0;
 } /* main */
diff --git a/tests/unit/test-literal-storage.c b/tests/unit/test-literal-storage.c
index 9d0af50e..2564bf61 100644
--- a/tests/unit/test-literal-storage.c
+++ b/tests/unit/test-literal-storage.c
@@ -129,6 +129,6 @@ main ()
   }
 
   ecma_finalize_lit_storage ();
-  jmem_finalize (true);
+  jmem_finalize ();
   return 0;
 } /* main */
diff --git a/tests/unit/test-poolman.c b/tests/unit/test-poolman.c
index 1a2abded..a951b2f5 100644
--- a/tests/unit/test-poolman.c
+++ b/tests/unit/test-poolman.c
@@ -82,7 +82,7 @@ main ()
   jmem_pools_stats_print ();
 #endif /* JMEM_STATS */
 
-  jmem_finalize (false);
+  jmem_finalize ();
 
   return 0;
 } /* main */
diff --git a/tests/unit/test-strings.c b/tests/unit/test-strings.c
index aa1ccb8e..e33aa569 100644
--- a/tests/unit/test-strings.c
+++ b/tests/unit/test-strings.c
@@ -217,7 +217,7 @@ main ()
   TEST_ASSERT (res_buf[2] == 0xBF);
 
   ecma_finalize ();
-  jmem_finalize (true);
+  jmem_finalize ();
 
   return 0;
 } /* main */
diff --git a/tools/build.py b/tools/build.py
index e93b4233..224fb5dc 100755
--- a/tools/build.py
+++ b/tools/build.py
@@ -40,10 +40,11 @@ def add_build_args(parser):
     parser.add_argument('--lto', choices=['on', 'off'], default='on', help='Enable link-time optimizations (default: %(default)s)')
     parser.add_argument('--profile', choices=['full', 'minimal'], default='full', help='Specify the profile (default: %(default)s)')
     parser.add_argument('--error-messages', choices=['on', 'off'], default='off', help='Enable error messages (default: %(default)s)')
-    parser.add_argument('--log', choices=['on', 'off'], default='off', help='Enable logging (default: %(default)s)')
     parser.add_argument('--valgrind', choices=['on', 'off'], default='off', help='Enable Valgrind support (default: %(default)s)')
     parser.add_argument('--valgrind-freya', choices=['on', 'off'], default='off', help='Enable Valgrind-Freya support (default: %(default)s)')
-    parser.add_argument('--mem-stats', choices=['on', 'off'], default='off', help='Enable memory-statistics (default: %(default)s)')
+    parser.add_argument('--show-opcodes', choices=['on', 'off'], default='off', help='Enable parser byte-code dumps (default: %(default)s)')
+    parser.add_argument('--show-regexp-opcodes', choices=['on', 'off'], default='off', help='Enable regexp byte-code dumps (default: %(default)s)')
+    parser.add_argument('--mem-stats', choices=['on', 'off'], default='off', help='Enable memory statistics (default: %(default)s)')
     parser.add_argument('--mem-stress-test', choices=['on', 'off'], default='off', help='Enable mem-stress test (default: %(default)s)')
     parser.add_argument('--snapshot-save', choices=['on', 'off'], default='on', help='Allow to save snapshot files (default: %(default)s)')
     parser.add_argument('--snapshot-exec', choices=['on', 'off'], default='on', help='Allow to execute snapshot files (default: %(default)s)')
@@ -75,9 +76,10 @@ def generate_build_options(arguments):
     build_options.append('-DCMAKE_BUILD_TYPE=%s' % arguments.build_type)
     build_options.append('-DFEATURE_PROFILE=%s' % arguments.profile)
     build_options.append('-DFEATURE_ERROR_MESSAGES=%s' % arguments.error_messages.upper())
-    build_options.append('-DFEATURE_LOG=%s' % arguments.log.upper())
     build_options.append('-DFEATURE_VALGRIND=%s' % arguments.valgrind.upper())
     build_options.append('-DFEATURE_VALGRIND_FREYA=%s' % arguments.valgrind_freya.upper())
+    build_options.append('-DFEATURE_PARSER_DUMP=%s' % arguments.show_opcodes.upper())
+    build_options.append('-DFEATURE_REGEXP_DUMP=%s' % arguments.show_regexp_opcodes.upper())
     build_options.append('-DFEATURE_MEM_STATS=%s' % arguments.mem_stats.upper())
     build_options.append('-DFEATURE_MEM_STRESS_TEST=%s' % arguments.mem_stress_test.upper())
     build_options.append('-DFEATURE_SNAPSHOT_SAVE=%s' % arguments.snapshot_save.upper())
diff --git a/tools/run-mem-stats-test.sh b/tools/run-mem-stats-test.sh
index 48705107..77f11a56 100755
--- a/tools/run-mem-stats-test.sh
+++ b/tools/run-mem-stats-test.sh
@@ -43,7 +43,7 @@ function is_mem_stats_build
   [ -x "$1" ] || fail_msg "Engine '$1' is not executable"
 
   tmpfile=`mktemp`
-  "$1" --mem-stats $tmpfile 2>&1 | grep -- "Ignoring memory statistics option because of '!JMEM_STATS' build configuration." 2>&1 > /dev/null
+  "$1" --mem-stats $tmpfile 2>&1 | grep -- "Ignoring JERRY_INIT_MEM_STATS flag because of !JMEM_STATS configuration." 2>&1 > /dev/null
   code=$?
   rm $tmpfile
 
diff --git a/tools/run-perf-test.sh b/tools/run-perf-test.sh
index 8de192b5..38ffa94c 100755
--- a/tools/run-perf-test.sh
+++ b/tools/run-perf-test.sh
@@ -32,7 +32,7 @@ function is_mem_stats_build() {
   [ -x "$1" ] || fail_msg "Engine '$1' is not executable"
 
   tmpfile=`mktemp`
-  "$1" --mem-stats $tmpfile 2>&1 | grep -- "Ignoring memory statistics option because of '!JMEM_STATS' build configuration." 2>&1 > /dev/null
+  "$1" --mem-stats $tmpfile 2>&1 | grep -- "Ignoring JERRY_INIT_MEM_STATS flag because of !JMEM_STATS configuration." 2>&1 > /dev/null
   code=$?
   rm $tmpfile
 
diff --git a/tools/run-tests.py b/tools/run-tests.py
index 39613dcd..7d414c07 100755
--- a/tools/run-tests.py
+++ b/tools/run-tests.py
@@ -80,11 +80,13 @@ jerry_test_suite_options.append(Options('jerry_test_suite-minimal-debug-snapshot
 # Test options for buildoption-test
 jerry_buildoptions = [
                       Options('buildoption_test-lto', ['--lto=on']),
-                      Options('buildoption_test-log', ['--log=on']),
                       Options('buildoption_test-error_messages', ['--error-messages=on']),
                       Options('buildoption_test-all_in_one', ['--all-in-one=on']),
                       Options('buildoption_test-valgrind', ['--valgrind=on']),
                       Options('buildoption_test-valgrind_freya', ['--valgrind-freya=on']),
+                      Options('buildoption_test-mem_stats', ['--mem-stats=on']),
+                      Options('buildoption_test-show_opcodes', ['--show-opcodes=on']),
+                      Options('buildoption_test-show_regexp_opcodes', ['--show-regexp-opcodes=on']),
                       Options('buildoption_test-jerry_libc', ['--jerry-libc=on', '--compiler-default-libc=off']),
                       Options('buildoption_test-compiler_default_libc', ['--compiler-default-libc=on', '--jerry-libc=off']),
                      ]