diff --git a/jerry-core/vm/opcodes-ecma-arithmetics.c b/jerry-core/vm/opcodes-ecma-arithmetics.c
index f11607c11..6651ef463 100644
--- a/jerry-core/vm/opcodes-ecma-arithmetics.c
+++ b/jerry-core/vm/opcodes-ecma-arithmetics.c
@@ -170,15 +170,16 @@ opfunc_addition (ecma_value_t left_value, /**< left value */
 } /* opfunc_addition */
 
 /**
- * 'Unary "+"' opcode handler.
+ * Unary operation opcode handler.
  *
- * See also: ECMA-262 v5, 11.4, 11.4.6
+ * See also: ECMA-262 v5, 11.4, 11.4.6, 11.4.7
  *
  * @return ecma value
  *         Returned value must be freed with ecma_free_value
  */
 ecma_value_t
-opfunc_unary_plus (ecma_value_t left_value) /**< left value */
+opfunc_unary_operation (ecma_value_t left_value, /**< left value */
+                        bool is_plus) /**< unary plus flag */
 {
   ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
 
@@ -186,36 +187,13 @@ opfunc_unary_plus (ecma_value_t left_value) /**< left value */
                                left_value,
                                ret_value);
 
-  ret_value = ecma_make_number_value (num_var_value);
+  ret_value = ecma_make_number_value (is_plus ? num_var_value
+                                               : ecma_number_negate (num_var_value));
 
   ECMA_OP_TO_NUMBER_FINALIZE (num_var_value);
 
   return ret_value;
-} /* opfunc_unary_plus */
-
-/**
- * 'Unary "-"' opcode handler.
- *
- * See also: ECMA-262 v5, 11.4, 11.4.7
- *
- * @return ecma value
- *         Returned value must be freed with ecma_free_value
- */
-ecma_value_t
-opfunc_unary_minus (ecma_value_t left_value) /**< left value */
-{
-  ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
-
-  ECMA_OP_TO_NUMBER_TRY_CATCH (num_var_value,
-                               left_value,
-                               ret_value);
-
-  ret_value = ecma_make_number_value (ecma_number_negate (num_var_value));
-
-  ECMA_OP_TO_NUMBER_FINALIZE (num_var_value);
-
-  return ret_value;
-} /* opfunc_unary_minus */
+} /* opfunc_unary_operation */
 
 /**
  * @}
diff --git a/jerry-core/vm/opcodes-ecma-equality.c b/jerry-core/vm/opcodes-ecma-equality.c
deleted file mode 100644
index 175c7a11c..000000000
--- a/jerry-core/vm/opcodes-ecma-equality.c
+++ /dev/null
@@ -1,90 +0,0 @@
-/* Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "ecma-builtins.h"
-#include "ecma-comparison.h"
-#include "ecma-exceptions.h"
-#include "ecma-function-object.h"
-#include "ecma-globals.h"
-#include "ecma-helpers.h"
-#include "ecma-lex-env.h"
-#include "ecma-try-catch-macro.h"
-#include "opcodes.h"
-#include "vm-defines.h"
-
-/** \addtogroup vm Virtual machine
- * @{
- *
- * \addtogroup vm_opcodes Opcodes
- * @{
- */
-
-/**
- * 'Equals' opcode handler.
- *
- * See also: ECMA-262 v5, 11.9.1
- *
- * @return ecma value
- *         Returned value must be freed with ecma_free_value
- */
-ecma_value_t
-opfunc_equal_value (ecma_value_t left_value, /**< left value */
-                    ecma_value_t right_value) /**< right value */
-{
-  JERRY_ASSERT (!ECMA_IS_VALUE_ERROR (left_value)
-                && !ECMA_IS_VALUE_ERROR (right_value));
-
-  ecma_value_t compare_result = ecma_op_abstract_equality_compare (left_value,
-                                                                   right_value);
-
-  JERRY_ASSERT (ecma_is_value_boolean (compare_result)
-                || ECMA_IS_VALUE_ERROR (compare_result));
-
-  return compare_result;
-} /* opfunc_equal_value */
-
-/**
- * 'Does-not-equals' opcode handler.
- *
- * See also: ECMA-262 v5, 11.9.2
- *
- * @return ecma value
- *         Returned value must be freed with ecma_free_value
- */
-ecma_value_t
-opfunc_not_equal_value (ecma_value_t left_value, /**< left value */
-                        ecma_value_t right_value) /**< right value */
-{
-  JERRY_ASSERT (!ECMA_IS_VALUE_ERROR (left_value)
-                && !ECMA_IS_VALUE_ERROR (right_value));
-
-  ecma_value_t compare_result = ecma_op_abstract_equality_compare (left_value,
-                                                                   right_value);
-
-  JERRY_ASSERT (ecma_is_value_boolean (compare_result)
-                || ECMA_IS_VALUE_ERROR (compare_result));
-
-  if (!ECMA_IS_VALUE_ERROR (compare_result))
-  {
-    compare_result = ecma_invert_boolean_value (compare_result);
-  }
-
-  return compare_result;
-} /* opfunc_not_equal_value */
-
-/**
- * @}
- * @}
- */
diff --git a/jerry-core/vm/opcodes-ecma-relational.c b/jerry-core/vm/opcodes-ecma-relational-equality.c
similarity index 55%
rename from jerry-core/vm/opcodes-ecma-relational.c
rename to jerry-core/vm/opcodes-ecma-relational-equality.c
index 4ccfb350c..c671f166c 100644
--- a/jerry-core/vm/opcodes-ecma-relational.c
+++ b/jerry-core/vm/opcodes-ecma-relational-equality.c
@@ -29,89 +29,46 @@
  */
 
 /**
- * 'Less-than' opcode handler.
- *
- * See also: ECMA-262 v5, 11.8.1
- *
- * @return ecma value
- *         Returned value must be freed with ecma_free_value
- */
+* Equality opcode handler.
+*
+* See also: ECMA-262 v5, 11.9.1, 11.9.2
+*
+* @return ecma value
+*         Returned value must be freed with ecma_free_value
+*/
 ecma_value_t
-opfunc_less_than (ecma_value_t left_value, /**< left value */
-                  ecma_value_t right_value) /**< right value */
+opfunc_equality (ecma_value_t left_value, /**< left value */
+                 ecma_value_t right_value) /**< right value */
 {
   JERRY_ASSERT (!ECMA_IS_VALUE_ERROR (left_value)
                 && !ECMA_IS_VALUE_ERROR (right_value));
 
-  ecma_value_t ret_value = ecma_op_abstract_relational_compare (left_value, right_value, true);
+  ecma_value_t compare_result = ecma_op_abstract_equality_compare (left_value, right_value);
 
-  if (ECMA_IS_VALUE_ERROR (ret_value))
-  {
-    return ret_value;
-  }
+  JERRY_ASSERT (ecma_is_value_boolean (compare_result)
+                || ECMA_IS_VALUE_ERROR (compare_result));
 
-  if (ecma_is_value_undefined (ret_value))
-  {
-    ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE);
-  }
-  else
-  {
-    JERRY_ASSERT (ecma_is_value_boolean (ret_value));
-  }
-
-  return ret_value;
-} /* opfunc_less_than */
+  return compare_result;
+} /* opfunc_equality */
 
 /**
- * 'Greater-than' opcode handler.
+ * Relation opcode handler.
  *
- * See also: ECMA-262 v5, 11.8.2
+ * See also: ECMA-262 v5, 11.8.1, 11.8.2, 11.8.3, 11.8.4
  *
  * @return ecma value
  *         Returned value must be freed with ecma_free_value
  */
 ecma_value_t
-opfunc_greater_than (ecma_value_t left_value, /**< left value */
-                     ecma_value_t right_value) /**< right value */
+opfunc_relation (ecma_value_t left_value, /**< left value */
+                 ecma_value_t right_value, /**< right value */
+                 bool left_first, /**< 'LeftFirst' flag */
+                 bool is_invert) /**< is invert */
 {
   JERRY_ASSERT (!ECMA_IS_VALUE_ERROR (left_value)
                 && !ECMA_IS_VALUE_ERROR (right_value));
 
-  ecma_value_t ret_value = ecma_op_abstract_relational_compare (left_value, right_value, false);
-
-  if (ECMA_IS_VALUE_ERROR (ret_value))
-  {
-    return ret_value;
-  }
-
-  if (ecma_is_value_undefined (ret_value))
-  {
-    ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE);
-  }
-  else
-  {
-    JERRY_ASSERT (ecma_is_value_boolean (ret_value));
-  }
-
-  return ret_value;
-} /* opfunc_greater_than */
-
-/**
- * 'Less-than-or-equal' opcode handler.
- *
- * See also: ECMA-262 v5, 11.8.3
- *
- * @return ecma value
- *         Returned value must be freed with ecma_free_value
- */
-ecma_value_t
-opfunc_less_or_equal_than (ecma_value_t left_value, /**< left value */
-                           ecma_value_t right_value) /**< right value */
-{
-  JERRY_ASSERT (!ECMA_IS_VALUE_ERROR (left_value)
-                && !ECMA_IS_VALUE_ERROR (right_value));
-
-  ecma_value_t ret_value = ecma_op_abstract_relational_compare (left_value, right_value, false);
+  ecma_value_t ret_value = ecma_op_abstract_relational_compare (left_value, right_value, left_first);
 
   if (ECMA_IS_VALUE_ERROR (ret_value))
   {
@@ -126,47 +83,14 @@ opfunc_less_or_equal_than (ecma_value_t left_value, /**< left value */
   {
     JERRY_ASSERT (ecma_is_value_boolean (ret_value));
 
-    ret_value = ecma_invert_boolean_value (ret_value);
+    if (is_invert)
+    {
+      ret_value = ecma_invert_boolean_value (ret_value);
+    }
   }
 
   return ret_value;
-} /* opfunc_less_or_equal_than */
-
-/**
- * 'Greater-than-or-equal' opcode handler.
- *
- * See also: ECMA-262 v5, 11.8.4
- *
- * @return ecma value
- *         Returned value must be freed with ecma_free_value
- */
-ecma_value_t
-opfunc_greater_or_equal_than (ecma_value_t left_value, /**< left value */
-                              ecma_value_t right_value) /**< right value */
-{
-  JERRY_ASSERT (!ECMA_IS_VALUE_ERROR (left_value)
-                && !ECMA_IS_VALUE_ERROR (right_value));
-
-  ecma_value_t ret_value = ecma_op_abstract_relational_compare (left_value, right_value, true);
-
-  if (ECMA_IS_VALUE_ERROR (ret_value))
-  {
-    return ret_value;
-  }
-
-  if (ecma_is_value_undefined (ret_value))
-  {
-    ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE);
-  }
-  else
-  {
-    JERRY_ASSERT (ecma_is_value_boolean (ret_value));
-
-    ret_value = ecma_invert_boolean_value (ret_value);
-  }
-
-  return ret_value;
-} /* opfunc_greater_or_equal_than */
+} /* opfunc_relation */
 
 /**
  * 'instanceof' opcode handler.
diff --git a/jerry-core/vm/opcodes.h b/jerry-core/vm/opcodes.h
index 225c383ad..f2c73c3ec 100644
--- a/jerry-core/vm/opcodes.h
+++ b/jerry-core/vm/opcodes.h
@@ -55,19 +55,13 @@ ecma_value_t
 vm_var_decl (vm_frame_ctx_t *frame_ctx_p, ecma_string_t *var_name_str_p);
 
 ecma_value_t
-opfunc_equal_value (ecma_value_t left_value, ecma_value_t right_value);
-
-ecma_value_t
-opfunc_not_equal_value (ecma_value_t left_value, ecma_value_t right_value);
+opfunc_equality (ecma_value_t left_value, ecma_value_t right_value);
 
 ecma_value_t
 do_number_arithmetic (number_arithmetic_op op, ecma_value_t left_value, ecma_value_t right_value);
 
 ecma_value_t
-opfunc_unary_plus (ecma_value_t left_value);
-
-ecma_value_t
-opfunc_unary_minus (ecma_value_t left_value);
+opfunc_unary_operation (ecma_value_t left_value, bool is_plus);
 
 ecma_value_t
 do_number_bitwise_logic (number_bitwise_logic_op op, ecma_value_t left_value, ecma_value_t right_value);
@@ -76,16 +70,7 @@ ecma_value_t
 opfunc_addition (ecma_value_t left_value, ecma_value_t right_value);
 
 ecma_value_t
-opfunc_less_than (ecma_value_t left_value, ecma_value_t right_value);
-
-ecma_value_t
-opfunc_greater_than (ecma_value_t left_value, ecma_value_t right_value);
-
-ecma_value_t
-opfunc_less_or_equal_than (ecma_value_t left_value, ecma_value_t right_value);
-
-ecma_value_t
-opfunc_greater_or_equal_than (ecma_value_t left_value, ecma_value_t right_value);
+opfunc_relation (ecma_value_t left_value, ecma_value_t right_value, bool left_first, bool is_invert);
 
 ecma_value_t
 opfunc_in (ecma_value_t left_value, ecma_value_t right_value);
diff --git a/jerry-core/vm/vm.c b/jerry-core/vm/vm.c
index dac89ddbc..4f8bd07d6 100644
--- a/jerry-core/vm/vm.c
+++ b/jerry-core/vm/vm.c
@@ -1578,20 +1578,9 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
           continue;
         }
         case VM_OC_PLUS:
-        {
-          result = opfunc_unary_plus (left_value);
-
-          if (ECMA_IS_VALUE_ERROR (result))
-          {
-            goto error;
-          }
-
-          *stack_top_p++ = result;
-          goto free_left_value;
-        }
         case VM_OC_MINUS:
         {
-          result = opfunc_unary_minus (left_value);
+          result = opfunc_unary_operation (left_value, VM_OC_GROUP_GET_INDEX (opcode_data) == VM_OC_PLUS);
 
           if (ECMA_IS_VALUE_ERROR (result))
           {
@@ -1886,7 +1875,7 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
         }
         case VM_OC_EQUAL:
         {
-          result = opfunc_equal_value (left_value, right_value);
+          result = opfunc_equality (left_value, right_value);
 
           if (ECMA_IS_VALUE_ERROR (result))
           {
@@ -1898,14 +1887,14 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
         }
         case VM_OC_NOT_EQUAL:
         {
-          result = opfunc_not_equal_value (left_value, right_value);
+          result = opfunc_equality (left_value, right_value);
 
           if (ECMA_IS_VALUE_ERROR (result))
           {
             goto error;
           }
 
-          *stack_top_p++ = result;
+          *stack_top_p++ = ecma_invert_boolean_value (result);
           goto free_both_values;
         }
         case VM_OC_STRICT_EQUAL:
@@ -2051,7 +2040,7 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
             goto free_both_values;
           }
 
-          result = opfunc_less_than (left_value, right_value);
+          result = opfunc_relation (left_value, right_value, true, false);
 
           if (ECMA_IS_VALUE_ERROR (result))
           {
@@ -2081,7 +2070,7 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
             goto free_both_values;
           }
 
-          result = opfunc_greater_than (left_value, right_value);
+          result = opfunc_relation (left_value, right_value, false, false);
 
           if (ECMA_IS_VALUE_ERROR (result))
           {
@@ -2111,7 +2100,7 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
             goto free_both_values;
           }
 
-          result = opfunc_less_or_equal_than (left_value, right_value);
+          result = opfunc_relation (left_value, right_value, false, true);
 
           if (ECMA_IS_VALUE_ERROR (result))
           {
@@ -2141,7 +2130,7 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
             goto free_both_values;
           }
 
-          result = opfunc_greater_or_equal_than (left_value, right_value);
+          result = opfunc_relation (left_value, right_value, true, true);
 
           if (ECMA_IS_VALUE_ERROR (result))
           {