Maintenance and merging of Valgrind and Valgrind-Freya code paths (#2362)

None of the code paths have been tested for long and especially the
Freya code paths have been long abandoned. This patch:
- Merges Valgrind-Freya into Valgrind code path (there should be no
  need to choose between them, Valgrind should work just fine).
- Removes leftover code (`VALGRIND_FREYA_CHECK_MEMPOOL_REQUEST` and
  `valgrind_freya_mempool_request`).
- Adds `JMEM_` prefix to Valgrind-related macros (to correctly
  leave the `VALGRIND_` prefix to Valgrind).
- Moves the definition of the Valgrind-related macros to a common
  header to avoid duplication.

Note: Adding a CI job to perform Valgrind Memchecks is left for
follow-up as it turns out to be excessively slow (>50 mins for a
`--jerry-tests --jerry-test-suite` run, and even a simple
`--jerry-tests` may get terminated prematurely because of timeout
issues).

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

5 files changed, 65 insertions, 148 deletions

diff --git a/jerry-core/CMakeLists.txt b/jerry-core/CMakeLists.txt
index 4056a2fb..a0c2aa62 100644
--- a/jerry-core/CMakeLists.txt
+++ b/jerry-core/CMakeLists.txt
@@ -33,7 +33,6 @@ set(FEATURE_SNAPSHOT_EXEC      OFF     CACHE BOOL   "Enable executing snapshot f
 set(FEATURE_SNAPSHOT_SAVE      OFF     CACHE BOOL   "Enable saving snapshot files?")
 set(FEATURE_SYSTEM_ALLOCATOR   OFF     CACHE BOOL   "Enable system allocator?")
 set(FEATURE_VALGRIND           OFF     CACHE BOOL   "Enable Valgrind support?")
-set(FEATURE_VALGRIND_FREYA     OFF     CACHE BOOL   "Enable Valgrind-Freya support?")
 set(FEATURE_VM_EXEC_STOP       OFF     CACHE BOOL   "Enable VM execution stopping?")
 set(MEM_HEAP_SIZE_KB           "512"   CACHE STRING "Size of memory heap, in kilobytes")
 
@@ -75,7 +74,6 @@ message(STATUS "FEATURE_SNAPSHOT_EXEC       " ${FEATURE_SNAPSHOT_EXEC} ${FEATURE
 message(STATUS "FEATURE_SNAPSHOT_SAVE       " ${FEATURE_SNAPSHOT_SAVE} ${FEATURE_SNAPSHOT_SAVE_MESSAGE})
 message(STATUS "FEATURE_SYSTEM_ALLOCATOR    " ${FEATURE_SYSTEM_ALLOCATOR})
 message(STATUS "FEATURE_VALGRIND            " ${FEATURE_VALGRIND})
-message(STATUS "FEATURE_VALGRIND_FREYA      " ${FEATURE_VALGRIND_FREYA})
 message(STATUS "FEATURE_VM_EXEC_STOP        " ${FEATURE_VM_EXEC_STOP})
 message(STATUS "MEM_HEAP_SIZE_KB            " ${MEM_HEAP_SIZE_KB})
 
@@ -262,12 +260,6 @@ if(FEATURE_VALGRIND)
   set(INCLUDE_CORE ${INCLUDE_CORE} ${INCLUDE_THIRD_PARTY_VALGRIND})
 endif()
 
-# Valgrind Freya
-if(FEATURE_VALGRIND_FREYA)
-  set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_VALGRIND_FREYA)
-  set(INCLUDE_CORE ${INCLUDE_CORE} ${INCLUDE_THIRD_PARTY_VALGRIND})
-endif()
-
 # Enable VM execution stopping
 if (FEATURE_VM_EXEC_STOP)
   set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_VM_EXEC_STOP)
diff --git a/jerry-core/jcontext/jcontext.h b/jerry-core/jcontext/jcontext.h
index 1206a50a..f1abe682 100644
--- a/jerry-core/jcontext/jcontext.h
+++ b/jerry-core/jcontext/jcontext.h
@@ -131,11 +131,6 @@ typedef struct
 #ifdef JMEM_STATS
   jmem_heap_stats_t jmem_heap_stats; /**< heap's memory usage statistics */
 #endif /* JMEM_STATS */
-
-#ifdef JERRY_VALGRIND_FREYA
-  uint8_t valgrind_freya_mempool_request; /**< Tells whether a pool manager
-                                           *   allocator request is in progress */
-#endif /* JERRY_VALGRIND_FREYA */
 } jerry_context_t;
 
 #ifndef CONFIG_ECMA_LCACHE_DISABLE
diff --git a/jerry-core/jmem/jmem-allocator-internal.h b/jerry-core/jmem/jmem-allocator-internal.h
index 41029cd4..47b3ee94 100644
--- a/jerry-core/jmem/jmem-allocator-internal.h
+++ b/jerry-core/jmem/jmem-allocator-internal.h
@@ -24,6 +24,27 @@
  * @{
  */
 
+ /**
+  * @{
+  * Valgrind-related options and headers
+  */
+ #ifdef JERRY_VALGRIND
+ # include "memcheck.h"
+
+ # define JMEM_VALGRIND_NOACCESS_SPACE(p, s)   VALGRIND_MAKE_MEM_NOACCESS((p), (s))
+ # define JMEM_VALGRIND_UNDEFINED_SPACE(p, s)  VALGRIND_MAKE_MEM_UNDEFINED((p), (s))
+ # define JMEM_VALGRIND_DEFINED_SPACE(p, s)    VALGRIND_MAKE_MEM_DEFINED((p), (s))
+ # define JMEM_VALGRIND_MALLOCLIKE_SPACE(p, s) VALGRIND_MALLOCLIKE_BLOCK((p), (s), 0, 0)
+ # define JMEM_VALGRIND_FREELIKE_SPACE(p)      VALGRIND_FREELIKE_BLOCK((p), 0)
+ #else /* !JERRY_VALGRIND */
+ # define JMEM_VALGRIND_NOACCESS_SPACE(p, s)
+ # define JMEM_VALGRIND_UNDEFINED_SPACE(p, s)
+ # define JMEM_VALGRIND_DEFINED_SPACE(p, s)
+ # define JMEM_VALGRIND_MALLOCLIKE_SPACE(p, s)
+ # define JMEM_VALGRIND_FREELIKE_SPACE(p)
+ #endif /* JERRY_VALGRIND */
+ /** @} */
+
 #ifdef JMEM_STATS
 void jmem_heap_stats_reset_peak (void);
 void jmem_heap_stats_print (void);
diff --git a/jerry-core/jmem/jmem-heap.c b/jerry-core/jmem/jmem-heap.c
index 98cddc61..0511a88a 100644
--- a/jerry-core/jmem/jmem-heap.c
+++ b/jerry-core/jmem/jmem-heap.c
@@ -33,53 +33,6 @@
  */
 
 /**
- * @{
- * Valgrind-related options and headers
- */
-#ifdef JERRY_VALGRIND
-# include "memcheck.h"
-
-# define VALGRIND_NOACCESS_SPACE(p, s)   VALGRIND_MAKE_MEM_NOACCESS((p), (s))
-# define VALGRIND_UNDEFINED_SPACE(p, s)  VALGRIND_MAKE_MEM_UNDEFINED((p), (s))
-# define VALGRIND_DEFINED_SPACE(p, s)    VALGRIND_MAKE_MEM_DEFINED((p), (s))
-
-#else /* !JERRY_VALGRIND */
-# define VALGRIND_NOACCESS_SPACE(p, s)
-# define VALGRIND_UNDEFINED_SPACE(p, s)
-# define VALGRIND_DEFINED_SPACE(p, s)
-#endif /* JERRY_VALGRIND */
-#ifdef JERRY_VALGRIND_FREYA
-
-#ifdef JERRY_VALGRIND
-#error Valgrind and valgrind-freya modes are not compatible.
-#endif /* JERRY_VALGRIND */
-
-#include "memcheck.h"
-
-# define VALGRIND_FREYA_CHECK_MEMPOOL_REQUEST \
-  bool mempool_request = JERRY_CONTEXT (valgrind_freya_mempool_request); \
-  JERRY_CONTEXT (valgrind_freya_mempool_request) = false
-
-# define VALGRIND_FREYA_MALLOCLIKE_SPACE(p, s) \
-  if (!mempool_request) \
-  { \
-    VALGRIND_MALLOCLIKE_BLOCK((p), (s), 0, 0); \
-  }
-
-# define VALGRIND_FREYA_FREELIKE_SPACE(p) \
-  if (!mempool_request) \
-  { \
-    VALGRIND_FREELIKE_BLOCK((p), 0); \
-  }
-
-#else /* !JERRY_VALGRIND_FREYA */
-# define VALGRIND_FREYA_CHECK_MEMPOOL_REQUEST
-# define VALGRIND_FREYA_MALLOCLIKE_SPACE(p, s)
-# define VALGRIND_FREYA_FREELIKE_SPACE(p)
-#endif /* JERRY_VALGRIND_FREYA */
-/** @} */
-
-/**
  * End of list marker.
  */
 #define JMEM_HEAP_END_OF_LIST ((uint32_t) 0xffffffff)
@@ -184,7 +137,7 @@ jmem_heap_init (void)
 
   JERRY_CONTEXT (jmem_heap_list_skip_p) = &JERRY_HEAP_CONTEXT (first);
 
-  VALGRIND_NOACCESS_SPACE (JERRY_HEAP_CONTEXT (area), JMEM_HEAP_AREA_SIZE);
+  JMEM_VALGRIND_NOACCESS_SPACE (JERRY_HEAP_CONTEXT (area), JMEM_HEAP_AREA_SIZE);
 
 #endif /* !JERRY_SYSTEM_ALLOCATOR */
   JMEM_HEAP_STAT_INIT ();
@@ -198,7 +151,7 @@ jmem_heap_finalize (void)
 {
   JERRY_ASSERT (JERRY_CONTEXT (jmem_heap_allocated_size) == 0);
 #ifndef JERRY_SYSTEM_ALLOCATOR
-  VALGRIND_NOACCESS_SPACE (&JERRY_HEAP_CONTEXT (first), JMEM_HEAP_SIZE);
+  JMEM_VALGRIND_NOACCESS_SPACE (&JERRY_HEAP_CONTEXT (first), JMEM_HEAP_SIZE);
 #endif /* !JERRY_SYSTEM_ALLOCATOR */
 } /* jmem_heap_finalize */
 
@@ -219,7 +172,7 @@ jmem_heap_alloc_block_internal (const size_t size) /**< size of requested block
   const size_t required_size = ((size + JMEM_ALIGNMENT - 1) / JMEM_ALIGNMENT) * JMEM_ALIGNMENT;
   jmem_heap_free_t *data_space_p = NULL;
 
-  VALGRIND_DEFINED_SPACE (&JERRY_HEAP_CONTEXT (first), sizeof (jmem_heap_free_t));
+  JMEM_VALGRIND_DEFINED_SPACE (&JERRY_HEAP_CONTEXT (first), sizeof (jmem_heap_free_t));
 
   /* Fast path for 8 byte chunks, first region is guaranteed to be sufficient. */
   if (required_size == JMEM_ALIGNMENT
@@ -228,7 +181,7 @@ jmem_heap_alloc_block_internal (const size_t size) /**< size of requested block
     data_space_p = JMEM_HEAP_GET_ADDR_FROM_OFFSET (JERRY_HEAP_CONTEXT (first).next_offset);
     JERRY_ASSERT (jmem_is_heap_pointer (data_space_p));
 
-    VALGRIND_DEFINED_SPACE (data_space_p, sizeof (jmem_heap_free_t));
+    JMEM_VALGRIND_DEFINED_SPACE (data_space_p, sizeof (jmem_heap_free_t));
     JERRY_CONTEXT (jmem_heap_allocated_size) += JMEM_ALIGNMENT;
     JMEM_HEAP_STAT_ALLOC_ITER ();
 
@@ -243,15 +196,15 @@ jmem_heap_alloc_block_internal (const size_t size) /**< size of requested block
       jmem_heap_free_t *remaining_p;
       remaining_p = JMEM_HEAP_GET_ADDR_FROM_OFFSET (JERRY_HEAP_CONTEXT (first).next_offset) + 1;
 
-      VALGRIND_DEFINED_SPACE (remaining_p, sizeof (jmem_heap_free_t));
+      JMEM_VALGRIND_DEFINED_SPACE (remaining_p, sizeof (jmem_heap_free_t));
       remaining_p->size = data_space_p->size - JMEM_ALIGNMENT;
       remaining_p->next_offset = data_space_p->next_offset;
-      VALGRIND_NOACCESS_SPACE (remaining_p, sizeof (jmem_heap_free_t));
+      JMEM_VALGRIND_NOACCESS_SPACE (remaining_p, sizeof (jmem_heap_free_t));
 
       JERRY_HEAP_CONTEXT (first).next_offset = JMEM_HEAP_GET_OFFSET_FROM_ADDR (remaining_p);
     }
 
-    VALGRIND_UNDEFINED_SPACE (data_space_p, sizeof (jmem_heap_free_t));
+    JMEM_VALGRIND_UNDEFINED_SPACE (data_space_p, sizeof (jmem_heap_free_t));
 
     if (JERRY_UNLIKELY (data_space_p == JERRY_CONTEXT (jmem_heap_list_skip_p)))
     {
@@ -268,7 +221,7 @@ jmem_heap_alloc_block_internal (const size_t size) /**< size of requested block
     {
       jmem_heap_free_t *current_p = JMEM_HEAP_GET_ADDR_FROM_OFFSET (current_offset);
       JERRY_ASSERT (jmem_is_heap_pointer (current_p));
-      VALGRIND_DEFINED_SPACE (current_p, sizeof (jmem_heap_free_t));
+      JMEM_VALGRIND_DEFINED_SPACE (current_p, sizeof (jmem_heap_free_t));
       JMEM_HEAP_STAT_ALLOC_ITER ();
 
       const uint32_t next_offset = current_p->next_offset;
@@ -288,23 +241,23 @@ jmem_heap_alloc_block_internal (const size_t size) /**< size of requested block
           jmem_heap_free_t *const remaining_p = (jmem_heap_free_t *) ((uint8_t *) current_p + required_size);
 
           /* Update metadata. */
-          VALGRIND_DEFINED_SPACE (remaining_p, sizeof (jmem_heap_free_t));
+          JMEM_VALGRIND_DEFINED_SPACE (remaining_p, sizeof (jmem_heap_free_t));
           remaining_p->size = current_p->size - (uint32_t) required_size;
           remaining_p->next_offset = next_offset;
-          VALGRIND_NOACCESS_SPACE (remaining_p, sizeof (jmem_heap_free_t));
+          JMEM_VALGRIND_NOACCESS_SPACE (remaining_p, sizeof (jmem_heap_free_t));
 
           /* Update list. */
-          VALGRIND_DEFINED_SPACE (prev_p, sizeof (jmem_heap_free_t));
+          JMEM_VALGRIND_DEFINED_SPACE (prev_p, sizeof (jmem_heap_free_t));
           prev_p->next_offset = JMEM_HEAP_GET_OFFSET_FROM_ADDR (remaining_p);
-          VALGRIND_NOACCESS_SPACE (prev_p, sizeof (jmem_heap_free_t));
+          JMEM_VALGRIND_NOACCESS_SPACE (prev_p, sizeof (jmem_heap_free_t));
         }
         /* Block is an exact fit. */
         else
         {
           /* Remove the region from the list. */
-          VALGRIND_DEFINED_SPACE (prev_p, sizeof (jmem_heap_free_t));
+          JMEM_VALGRIND_DEFINED_SPACE (prev_p, sizeof (jmem_heap_free_t));
           prev_p->next_offset = next_offset;
-          VALGRIND_NOACCESS_SPACE (prev_p, sizeof (jmem_heap_free_t));
+          JMEM_VALGRIND_NOACCESS_SPACE (prev_p, sizeof (jmem_heap_free_t));
         }
 
         JERRY_CONTEXT (jmem_heap_list_skip_p) = prev_p;
@@ -313,7 +266,7 @@ jmem_heap_alloc_block_internal (const size_t size) /**< size of requested block
         break;
       }
 
-      VALGRIND_NOACCESS_SPACE (current_p, sizeof (jmem_heap_free_t));
+      JMEM_VALGRIND_NOACCESS_SPACE (current_p, sizeof (jmem_heap_free_t));
       /* Next in list. */
       prev_p = current_p;
       current_offset = next_offset;
@@ -325,7 +278,7 @@ jmem_heap_alloc_block_internal (const size_t size) /**< size of requested block
     JERRY_CONTEXT (jmem_heap_limit) += CONFIG_MEM_HEAP_DESIRED_LIMIT;
   }
 
-  VALGRIND_NOACCESS_SPACE (&JERRY_HEAP_CONTEXT (first), sizeof (jmem_heap_free_t));
+  JMEM_VALGRIND_NOACCESS_SPACE (&JERRY_HEAP_CONTEXT (first), sizeof (jmem_heap_free_t));
 
   if (JERRY_UNLIKELY (!data_space_p))
   {
@@ -333,7 +286,7 @@ jmem_heap_alloc_block_internal (const size_t size) /**< size of requested block
   }
 
   JERRY_ASSERT ((uintptr_t) data_space_p % JMEM_ALIGNMENT == 0);
-  VALGRIND_UNDEFINED_SPACE (data_space_p, size);
+  JMEM_VALGRIND_UNDEFINED_SPACE (data_space_p, size);
   JMEM_HEAP_STAT_ALLOC (size);
 
   return (void *) data_space_p;
@@ -364,8 +317,6 @@ jmem_heap_gc_and_alloc_block (const size_t size,      /**< required memory size
     return NULL;
   }
 
-  VALGRIND_FREYA_CHECK_MEMPOOL_REQUEST;
-
 #ifdef JMEM_GC_BEFORE_EACH_ALLOC
   jmem_run_free_unused_memory_callbacks (JMEM_FREE_UNUSED_MEMORY_SEVERITY_HIGH);
 #endif /* JMEM_GC_BEFORE_EACH_ALLOC */
@@ -379,7 +330,7 @@ jmem_heap_gc_and_alloc_block (const size_t size,      /**< required memory size
 
   if (JERRY_LIKELY (data_space_p != NULL))
   {
-    VALGRIND_FREYA_MALLOCLIKE_SPACE (data_space_p, size);
+    JMEM_VALGRIND_MALLOCLIKE_SPACE (data_space_p, size);
     return data_space_p;
   }
 
@@ -393,7 +344,7 @@ jmem_heap_gc_and_alloc_block (const size_t size,      /**< required memory size
 
     if (JERRY_LIKELY (data_space_p != NULL))
     {
-      VALGRIND_FREYA_MALLOCLIKE_SPACE (data_space_p, size);
+      JMEM_VALGRIND_MALLOCLIKE_SPACE (data_space_p, size);
       return data_space_p;
     }
   }
@@ -448,22 +399,20 @@ jmem_heap_free_block (void *ptr, /**< pointer to beginning of data space of the
                       const size_t size) /**< size of allocated region */
 {
 #ifndef JERRY_SYSTEM_ALLOCATOR
-  VALGRIND_FREYA_CHECK_MEMPOOL_REQUEST;
-
   /* checking that ptr points to the heap */
   JERRY_ASSERT (jmem_is_heap_pointer (ptr));
   JERRY_ASSERT (size > 0);
   JERRY_ASSERT (JERRY_CONTEXT (jmem_heap_limit) >= JERRY_CONTEXT (jmem_heap_allocated_size));
 
-  VALGRIND_FREYA_FREELIKE_SPACE (ptr);
-  VALGRIND_NOACCESS_SPACE (ptr, size);
+  JMEM_VALGRIND_FREELIKE_SPACE (ptr);
+  JMEM_VALGRIND_NOACCESS_SPACE (ptr, size);
   JMEM_HEAP_STAT_FREE_ITER ();
 
   jmem_heap_free_t *block_p = (jmem_heap_free_t *) ptr;
   jmem_heap_free_t *prev_p;
   jmem_heap_free_t *next_p;
 
-  VALGRIND_DEFINED_SPACE (&JERRY_HEAP_CONTEXT (first), sizeof (jmem_heap_free_t));
+  JMEM_VALGRIND_DEFINED_SPACE (&JERRY_HEAP_CONTEXT (first), sizeof (jmem_heap_free_t));
 
   if (block_p > JERRY_CONTEXT (jmem_heap_list_skip_p))
   {
@@ -479,34 +428,34 @@ jmem_heap_free_block (void *ptr, /**< pointer to beginning of data space of the
   JERRY_ASSERT (jmem_is_heap_pointer (block_p));
   const uint32_t block_offset = JMEM_HEAP_GET_OFFSET_FROM_ADDR (block_p);
 
-  VALGRIND_DEFINED_SPACE (prev_p, sizeof (jmem_heap_free_t));
+  JMEM_VALGRIND_DEFINED_SPACE (prev_p, sizeof (jmem_heap_free_t));
   /* Find position of region in the list. */
   while (prev_p->next_offset < block_offset)
   {
     next_p = JMEM_HEAP_GET_ADDR_FROM_OFFSET (prev_p->next_offset);
     JERRY_ASSERT (jmem_is_heap_pointer (next_p));
 
-    VALGRIND_DEFINED_SPACE (next_p, sizeof (jmem_heap_free_t));
-    VALGRIND_NOACCESS_SPACE (prev_p, sizeof (jmem_heap_free_t));
+    JMEM_VALGRIND_DEFINED_SPACE (next_p, sizeof (jmem_heap_free_t));
+    JMEM_VALGRIND_NOACCESS_SPACE (prev_p, sizeof (jmem_heap_free_t));
     prev_p = next_p;
 
     JMEM_HEAP_STAT_FREE_ITER ();
   }
 
   next_p = JMEM_HEAP_GET_ADDR_FROM_OFFSET (prev_p->next_offset);
-  VALGRIND_DEFINED_SPACE (next_p, sizeof (jmem_heap_free_t));
+  JMEM_VALGRIND_DEFINED_SPACE (next_p, sizeof (jmem_heap_free_t));
 
   /* Realign size */
   const size_t aligned_size = (size + JMEM_ALIGNMENT - 1) / JMEM_ALIGNMENT * JMEM_ALIGNMENT;
 
-  VALGRIND_DEFINED_SPACE (block_p, sizeof (jmem_heap_free_t));
-  VALGRIND_DEFINED_SPACE (prev_p, sizeof (jmem_heap_free_t));
+  JMEM_VALGRIND_DEFINED_SPACE (block_p, sizeof (jmem_heap_free_t));
+  JMEM_VALGRIND_DEFINED_SPACE (prev_p, sizeof (jmem_heap_free_t));
   /* Update prev. */
   if (jmem_heap_get_region_end (prev_p) == block_p)
   {
     /* Can be merged. */
     prev_p->size += (uint32_t) aligned_size;
-    VALGRIND_NOACCESS_SPACE (block_p, sizeof (jmem_heap_free_t));
+    JMEM_VALGRIND_NOACCESS_SPACE (block_p, sizeof (jmem_heap_free_t));
     block_p = prev_p;
   }
   else
@@ -515,7 +464,7 @@ jmem_heap_free_block (void *ptr, /**< pointer to beginning of data space of the
     prev_p->next_offset = block_offset;
   }
 
-  VALGRIND_DEFINED_SPACE (next_p, sizeof (jmem_heap_free_t));
+  JMEM_VALGRIND_DEFINED_SPACE (next_p, sizeof (jmem_heap_free_t));
   /* Update next. */
   if (jmem_heap_get_region_end (block_p) == next_p)
   {
@@ -530,9 +479,9 @@ jmem_heap_free_block (void *ptr, /**< pointer to beginning of data space of the
 
   JERRY_CONTEXT (jmem_heap_list_skip_p) = prev_p;
 
-  VALGRIND_NOACCESS_SPACE (prev_p, sizeof (jmem_heap_free_t));
-  VALGRIND_NOACCESS_SPACE (block_p, size);
-  VALGRIND_NOACCESS_SPACE (next_p, sizeof (jmem_heap_free_t));
+  JMEM_VALGRIND_NOACCESS_SPACE (prev_p, sizeof (jmem_heap_free_t));
+  JMEM_VALGRIND_NOACCESS_SPACE (block_p, size);
+  JMEM_VALGRIND_NOACCESS_SPACE (next_p, sizeof (jmem_heap_free_t));
 
   JERRY_ASSERT (JERRY_CONTEXT (jmem_heap_allocated_size) > 0);
   JERRY_CONTEXT (jmem_heap_allocated_size) -= aligned_size;
@@ -542,7 +491,7 @@ jmem_heap_free_block (void *ptr, /**< pointer to beginning of data space of the
     JERRY_CONTEXT (jmem_heap_limit) -= CONFIG_MEM_HEAP_DESIRED_LIMIT;
   }
 
-  VALGRIND_NOACCESS_SPACE (&JERRY_HEAP_CONTEXT (first), sizeof (jmem_heap_free_t));
+  JMEM_VALGRIND_NOACCESS_SPACE (&JERRY_HEAP_CONTEXT (first), sizeof (jmem_heap_free_t));
   JERRY_ASSERT (JERRY_CONTEXT (jmem_heap_limit) >= JERRY_CONTEXT (jmem_heap_allocated_size));
   JMEM_HEAP_STAT_FREE (size);
 #else /* JERRY_SYSTEM_ALLOCATOR */
@@ -728,13 +677,6 @@ jmem_heap_stat_free_iter (void)
 #endif /* !JERRY_SYSTEM_ALLOCATOR */
 #endif /* JMEM_STATS */
 
-#undef VALGRIND_NOACCESS_SPACE
-#undef VALGRIND_UNDEFINED_SPACE
-#undef VALGRIND_DEFINED_SPACE
-#undef VALGRIND_FREYA_CHECK_MEMPOOL_REQUEST
-#undef VALGRIND_FREYA_MALLOCLIKE_SPACE
-#undef VALGRIND_FREYA_FREELIKE_SPACE
-
 /**
  * @}
  * @}
diff --git a/jerry-core/jmem/jmem-poolman.c b/jerry-core/jmem/jmem-poolman.c
index ac7f63a7..d34e94ee 100644
--- a/jerry-core/jmem/jmem-poolman.c
+++ b/jerry-core/jmem/jmem-poolman.c
@@ -32,33 +32,6 @@
  */
 
 /**
- * @{
- * Valgrind-related options and headers
- */
-#ifdef JERRY_VALGRIND
-# include "memcheck.h"
-
-# define VALGRIND_NOACCESS_SPACE(p, s)   VALGRIND_MAKE_MEM_NOACCESS((p), (s))
-# define VALGRIND_UNDEFINED_SPACE(p, s)  VALGRIND_MAKE_MEM_UNDEFINED((p), (s))
-# define VALGRIND_DEFINED_SPACE(p, s)    VALGRIND_MAKE_MEM_DEFINED((p), (s))
-#else /* !JERRY_VALGRIND */
-# define VALGRIND_NOACCESS_SPACE(p, s)
-# define VALGRIND_UNDEFINED_SPACE(p, s)
-# define VALGRIND_DEFINED_SPACE(p, s)
-#endif /* JERRY_VALGRIND */
-
-#ifdef JERRY_VALGRIND_FREYA
-# include "memcheck.h"
-
-# define VALGRIND_FREYA_MALLOCLIKE_SPACE(p, s) VALGRIND_MALLOCLIKE_BLOCK((p), (s), 0, 0)
-# define VALGRIND_FREYA_FREELIKE_SPACE(p)      VALGRIND_FREELIKE_BLOCK((p), 0)
-#else /* !JERRY_VALGRIND_FREYA */
-# define VALGRIND_FREYA_MALLOCLIKE_SPACE(p, s)
-# define VALGRIND_FREYA_FREELIKE_SPACE(p)
-#endif /* JERRY_VALGRIND_FREYA */
-/** @} */
-
-/**
  * Finalize pool manager
  */
 void
@@ -96,11 +69,11 @@ jmem_pools_alloc (size_t size) /**< size of the chunk */
     {
       const jmem_pools_chunk_t *const chunk_p = JERRY_CONTEXT (jmem_free_8_byte_chunk_p);
 
-      VALGRIND_DEFINED_SPACE (chunk_p, sizeof (jmem_pools_chunk_t));
+      JMEM_VALGRIND_DEFINED_SPACE (chunk_p, sizeof (jmem_pools_chunk_t));
 
       JERRY_CONTEXT (jmem_free_8_byte_chunk_p) = chunk_p->next_p;
 
-      VALGRIND_UNDEFINED_SPACE (chunk_p, sizeof (jmem_pools_chunk_t));
+      JMEM_VALGRIND_UNDEFINED_SPACE (chunk_p, sizeof (jmem_pools_chunk_t));
 
       return (void *) chunk_p;
     }
@@ -118,11 +91,11 @@ jmem_pools_alloc (size_t size) /**< size of the chunk */
   {
     const jmem_pools_chunk_t *const chunk_p = JERRY_CONTEXT (jmem_free_16_byte_chunk_p);
 
-    VALGRIND_DEFINED_SPACE (chunk_p, sizeof (jmem_pools_chunk_t));
+    JMEM_VALGRIND_DEFINED_SPACE (chunk_p, sizeof (jmem_pools_chunk_t));
 
     JERRY_CONTEXT (jmem_free_16_byte_chunk_p) = chunk_p->next_p;
 
-    VALGRIND_UNDEFINED_SPACE (chunk_p, sizeof (jmem_pools_chunk_t));
+    JMEM_VALGRIND_UNDEFINED_SPACE (chunk_p, sizeof (jmem_pools_chunk_t));
 
     return (void *) chunk_p;
   }
@@ -144,7 +117,7 @@ jmem_pools_free (void *chunk_p, /**< pointer to the chunk */
 
   jmem_pools_chunk_t *const chunk_to_free_p = (jmem_pools_chunk_t *) chunk_p;
 
-  VALGRIND_DEFINED_SPACE (chunk_to_free_p, size);
+  JMEM_VALGRIND_DEFINED_SPACE (chunk_to_free_p, size);
 
 #ifdef JERRY_CPOINTER_32_BIT
   if (size <= 8)
@@ -167,7 +140,7 @@ jmem_pools_free (void *chunk_p, /**< pointer to the chunk */
   }
 #endif /* JERRY_CPOINTER_32_BIT */
 
-  VALGRIND_NOACCESS_SPACE (chunk_to_free_p, size);
+  JMEM_VALGRIND_NOACCESS_SPACE (chunk_to_free_p, size);
 } /* jmem_pools_free */
 
 /**
@@ -181,9 +154,9 @@ jmem_pools_collect_empty (void)
 
   while (chunk_p)
   {
-    VALGRIND_DEFINED_SPACE (chunk_p, sizeof (jmem_pools_chunk_t));
+    JMEM_VALGRIND_DEFINED_SPACE (chunk_p, sizeof (jmem_pools_chunk_t));
     jmem_pools_chunk_t *const next_p = chunk_p->next_p;
-    VALGRIND_NOACCESS_SPACE (chunk_p, sizeof (jmem_pools_chunk_t));
+    JMEM_VALGRIND_NOACCESS_SPACE (chunk_p, sizeof (jmem_pools_chunk_t));
 
     jmem_heap_free_block (chunk_p, 8);
     chunk_p = next_p;
@@ -195,9 +168,9 @@ jmem_pools_collect_empty (void)
 
   while (chunk_p)
   {
-    VALGRIND_DEFINED_SPACE (chunk_p, sizeof (jmem_pools_chunk_t));
+    JMEM_VALGRIND_DEFINED_SPACE (chunk_p, sizeof (jmem_pools_chunk_t));
     jmem_pools_chunk_t *const next_p = chunk_p->next_p;
-    VALGRIND_NOACCESS_SPACE (chunk_p, sizeof (jmem_pools_chunk_t));
+    JMEM_VALGRIND_NOACCESS_SPACE (chunk_p, sizeof (jmem_pools_chunk_t));
 
     jmem_heap_free_block (chunk_p, 16);
     chunk_p = next_p;
@@ -205,12 +178,6 @@ jmem_pools_collect_empty (void)
 #endif /* JERRY_CPOINTER_32_BIT */
 } /* jmem_pools_collect_empty */
 
-#undef VALGRIND_NOACCESS_SPACE
-#undef VALGRIND_UNDEFINED_SPACE
-#undef VALGRIND_DEFINED_SPACE
-#undef VALGRIND_FREYA_MALLOCLIKE_SPACE
-#undef VALGRIND_FREYA_FREELIKE_SPACE
-
 /**
  * @}
  * @}