Improve BigInt support (#4118)

This patch adds several small features:
- Support right shift with negative numbers
- Support exponentation operator
- BigInts can be enabled in ES5.1 mode
- Remove dead code from ecma_deref_bigint
- Support longer BigInt literals in the parser
- Fix various BigInt comparison issues
- Do not discard unary plus for BigInt constants

JerryScript-DCO-1.0-Signed-off-by: Zoltan Herczeg zherczeg.u-szeged@partner.samsung.com

jerry-core/ecma/base/ecma-helpers.c

@@ -1271,11 +1271,7 @@ ecma_deref_bigint (ecma_extended_primitive_t *bigint_p) /**< bigint value */
 
   uint32_t size = ECMA_BIGINT_GET_SIZE (bigint_p);
 
-  if (size == 0)
-  {
-    jmem_pools_free (bigint_p, sizeof (ecma_extended_primitive_t));
-    return;
-  }
+  JERRY_ASSERT (size > 0);
 
   size_t mem_size = ECMA_BIGINT_GET_BYTE_SIZE (size) + sizeof (ecma_extended_primitive_t);
   jmem_heap_free_block (bigint_p, mem_size);

jerry-core/ecma/builtin-objects/ecma-builtins.inc.h

@@ -678,6 +678,8 @@ BUILTIN (ECMA_BUILTIN_ID_MAP_ITERATOR_PROTOTYPE,
          map_iterator_prototype)
 #endif /* ENABLED (JERRY_BUILTIN_SET) */
 
+#endif /* ENABLED (JERRY_ESNEXT) */
+
 #if ENABLED (JERRY_BUILTIN_BIGINT)
 /* The %BigInt.prototype% object */
 BUILTIN (ECMA_BUILTIN_ID_BIGINT_PROTOTYPE,
@@ -694,8 +696,6 @@ BUILTIN_ROUTINE (ECMA_BUILTIN_ID_BIGINT,
                  bigint)
 #endif /* ENABLED (JERRY_BUILTIN_BIGINT) */
 
-#endif /* ENABLED (JERRY_ESNEXT) */
-
 #if ENABLED (JERRY_BUILTIN_DATAVIEW)
 /* The DataView prototype object (ECMA-262 v6, 24.2.3.1) */
 BUILTIN (ECMA_BUILTIN_ID_DATAVIEW_PROTOTYPE,

jerry-core/ecma/operations/ecma-big-uint.c

@@ -94,23 +94,38 @@ ecma_big_uint_extend (ecma_extended_primitive_t *value_p, /**< BigUInt value */
 } /* ecma_big_uint_extend */
 
 /**
- * Discard the high-order digits of a BigUInt
+ * Helper function which discards the leading zero digits of a BigUInt value
  *
- * @return BigUInt value, NULL on error
+ * @return new BigUInt value, NULL on error
  */
 static ecma_extended_primitive_t *
-ecma_big_uint_shrink_value (ecma_extended_primitive_t *value_p, /**< BigUInt value */
-                            uint32_t new_size) /**< new size, which is smaller than the original size */
+ecma_big_uint_normalize_result (ecma_extended_primitive_t *value_p, /**< BigUInt value */
+                                ecma_bigint_digit_t *last_digit_p) /**< points to the end of BigUInt */
 {
-  JERRY_ASSERT (value_p != NULL);
-  JERRY_ASSERT (ECMA_BIGINT_GET_SIZE (value_p) > new_size);
+  JERRY_ASSERT (last_digit_p[-1] == 0);
 
-  if (new_size == 0)
+  ecma_bigint_digit_t *first_digit_p = ECMA_BIGINT_GET_DIGITS (value_p, 0);
+
+  /* The following code is tricky. The value stored in first_digit_p[-1] is the size
+   * of the BigUInt value, and it cannot be zero. Hence the loop below will terminate. */
+  JERRY_ASSERT (first_digit_p[-1] != 0);
+
+  do
+  {
+    --last_digit_p;
+  }
+  while (last_digit_p[-1] == 0);
+
+  JERRY_ASSERT (last_digit_p >= first_digit_p);
+
+  if (first_digit_p == last_digit_p)
   {
     ecma_deref_bigint (value_p);
     return ECMA_BIGINT_POINTER_TO_ZERO;
   }
 
+  uint32_t new_size = (uint32_t) ((uint8_t *) last_digit_p - (uint8_t *) first_digit_p);
+
   if (ECMA_BIGINT_SIZE_IS_ODD (new_size)
       && ((new_size + sizeof (ecma_bigint_digit_t)) == ECMA_BIGINT_GET_SIZE (value_p)))
   {
@@ -130,7 +145,42 @@ ecma_big_uint_shrink_value (ecma_extended_primitive_t *value_p, /**< BigUInt val
   ecma_deref_bigint (value_p);
 
   return result_p;
-} /* ecma_big_uint_shrink_value */
+} /* ecma_big_uint_normalize_result */
+
+/**
+ * Helper function which increases the result by 1 and extends or shrinks the BigUInt when necessary
+ *
+ * @return new BigUInt value, NULL on error
+ */
+static ecma_extended_primitive_t *
+ecma_big_uint_increase_result (ecma_extended_primitive_t *value_p) /**< BigUInt value */
+{
+  uint32_t size = ECMA_BIGINT_GET_SIZE (value_p);
+
+  JERRY_ASSERT (size > 0);
+
+  ecma_bigint_digit_t *first_digit_p = ECMA_BIGINT_GET_DIGITS (value_p, 0);
+  ecma_bigint_digit_t *last_digit_p = ECMA_BIGINT_GET_DIGITS (value_p, size);
+
+  while (*first_digit_p == ~((ecma_bigint_digit_t) 0))
+  {
+    *first_digit_p++ = 0;
+
+    if (first_digit_p == last_digit_p)
+    {
+      return ecma_big_uint_extend (value_p, 1);
+    }
+  }
+
+  (*first_digit_p)++;
+
+  if (last_digit_p[-1] != 0)
+  {
+    return value_p;
+  }
+
+  return ecma_big_uint_normalize_result (value_p, last_digit_p);
+} /* ecma_big_uint_increase_result */
 
 /**
  * Compare two BigUInt numbers
@@ -376,7 +426,7 @@ ecma_big_uint_to_string (ecma_extended_primitive_t *value_p, /**< BigUInt value
 /**
  * Increase the value of a BigUInt value by 1
  *
- * return new BigInt value, NULL on error
+ * return new BigUInt value, NULL on error
  */
 ecma_extended_primitive_t *
 ecma_big_uint_increase (ecma_extended_primitive_t *value_p) /**< BigUInt value */
@@ -441,7 +491,7 @@ ecma_big_uint_increase (ecma_extended_primitive_t *value_p) /**< BigUInt value *
 /**
  * Decrease the value of a BigUInt value by 1
  *
- * return new BigInt value, NULL on error
+ * return new BigUInt value, NULL on error
  */
 ecma_extended_primitive_t *
 ecma_big_uint_decrease (ecma_extended_primitive_t *value_p) /**< BigUInt value */
@@ -508,7 +558,7 @@ ecma_big_uint_decrease (ecma_extended_primitive_t *value_p) /**< BigUInt value *
 /**
  * Add right BigUInt value to the left BigUInt value
  *
- * return new BigInt value, NULL on error
+ * return new BigUInt value, NULL on error
  */
 ecma_extended_primitive_t *
 ecma_big_uint_add (ecma_extended_primitive_t *left_value_p, /**< left BigUInt value */
@@ -609,7 +659,7 @@ ecma_big_uint_add (ecma_extended_primitive_t *left_value_p, /**< left BigUInt va
 /**
  * Substract right BigUInt value from the left BigUInt value
  *
- * return new BigInt value, NULL on error
+ * return new BigUInt value, NULL on error
  */
 ecma_extended_primitive_t *
 ecma_big_uint_sub (ecma_extended_primitive_t *left_value_p, /**< left BigUInt value */
@@ -683,29 +733,18 @@ ecma_big_uint_sub (ecma_extended_primitive_t *left_value_p, /**< left BigUInt va
     return result_p;
   }
 
-  ecma_bigint_digit_t *new_end_p = current_p;
-
-  if (new_end_p[-1] != 0)
+  if (current_p[-1] != 0)
   {
     return result_p;
   }
 
-  do
-  {
-    new_end_p--;
-
-    JERRY_ASSERT (new_end_p > ECMA_BIGINT_GET_DIGITS (result_p, 0));
-  }
-  while (new_end_p[-1] == 0);
-
-  ecma_bigint_digit_t *first_digit_p = ECMA_BIGINT_GET_DIGITS (result_p, 0);
-  return ecma_big_uint_shrink_value (result_p, (uint32_t) ((uint8_t *) new_end_p - (uint8_t *) first_digit_p));
+  return ecma_big_uint_normalize_result (result_p, current_p);
 } /* ecma_big_uint_sub */
 
 /**
  * Multiply two BigUInt values
  *
- * return new BigInt value, NULL on error
+ * return new BigUInt value, NULL on error
  */
 ecma_extended_primitive_t *
 ecma_big_uint_mul (ecma_extended_primitive_t *left_value_p, /**< left BigUInt value */
@@ -840,7 +879,7 @@ ecma_big_uint_mul (ecma_extended_primitive_t *left_value_p, /**< left BigUInt va
 /**
  * Count the number of leading zero bits of a digit
  *
- * return new BigInt value, NULL on error
+ * return new BigUInt value, NULL on error
  */
 static ecma_bigint_digit_t
 ecma_big_uint_count_leading_zero (ecma_bigint_digit_t digit) /**< digit value */
@@ -866,7 +905,7 @@ ecma_big_uint_count_leading_zero (ecma_bigint_digit_t digit) /**< digit value */
 /**
  * Divide left BigUInt value with right digit value
  *
- * return new BigInt value, NULL on error
+ * return new BigUInt value, NULL on error
  */
 static ecma_extended_primitive_t *
 ecma_big_uint_div_digit (ecma_extended_primitive_t *left_value_p, /**< left BigUInt value */
@@ -951,7 +990,7 @@ ecma_big_uint_div_digit (ecma_extended_primitive_t *left_value_p, /**< left BigU
 } /* ecma_big_uint_div_digit */
 
 /**
- * Shift left BigInt digits
+ * Shift left a BigUInt value by a digit value
  *
  * return newly allocated buffer, NULL on error
  */
@@ -1014,7 +1053,7 @@ ecma_big_uint_div_shift_left (ecma_extended_primitive_t *value_p, /**< BigUInt v
 /**
  * Divide left BigUInt value with right BigUInt value
  *
- * return new BigInt value, NULL on error
+ * return new BigUInt value, NULL on error
  */
 ecma_extended_primitive_t *
 ecma_big_uint_div_mod (ecma_extended_primitive_t *dividend_value_p, /**< divider BigUInt value */
@@ -1279,9 +1318,9 @@ error:
 } /* ecma_big_uint_div_mod */
 
 /**
- * Shift left BigInt values by an uint32 value
+ * Shift left BigUInt values by an uint32 value
  *
- * return new BigInt value, NULL on error
+ * return new BigUInt value, NULL on error
  */
 ecma_extended_primitive_t *
 ecma_big_uint_shift_left (ecma_extended_primitive_t *left_value_p, /**< left BigUInt value */
@@ -1352,13 +1391,14 @@ ecma_big_uint_shift_left (ecma_extended_primitive_t *left_value_p, /**< left Big
 } /* ecma_big_uint_shift_left */
 
 /**
- * Shift right BigInt values by an uint32 value
+ * Shift right BigUInt values by an uint32 value
  *
- * @return new BigInt value, NULL on error
+ * @return new BigUInt value, NULL on error
  */
 ecma_extended_primitive_t *
 ecma_big_uint_shift_right (ecma_extended_primitive_t *left_value_p,  /**< left BigUInt value */
-                           uint32_t right_value) /**< shift value */
+                           uint32_t right_value, /**< shift value */
+                           bool increase_result) /**< increase result */
 {
   JERRY_ASSERT (right_value > 0);
 
@@ -1380,7 +1420,39 @@ ecma_big_uint_shift_right (ecma_extended_primitive_t *left_value_p,  /**< left B
 
   if (left_size <= crop_size)
   {
-    return ECMA_BIGINT_POINTER_TO_ZERO;
+    if (JERRY_LIKELY (!increase_result))
+    {
+      return ECMA_BIGINT_POINTER_TO_ZERO;
+    }
+
+    ecma_extended_primitive_t *result_value_p = ecma_bigint_create (sizeof (ecma_bigint_digit_t));
+    if (result_value_p != NULL)
+    {
+      *ECMA_BIGINT_GET_DIGITS (result_value_p, 0) = 1;
+    }
+    return result_value_p;
+  }
+
+  if (JERRY_UNLIKELY (increase_result)
+      && (shift_right == 0
+          || (*ECMA_BIGINT_GET_DIGITS (left_value_p, crop_size) << shift_left) == 0))
+  {
+    ecma_bigint_digit_t *left_p = ECMA_BIGINT_GET_DIGITS (left_value_p, 0);
+    ecma_bigint_digit_t *left_end_p = ECMA_BIGINT_GET_DIGITS (left_value_p, crop_size);
+
+    while (left_p < left_end_p)
+    {
+      if (*left_p != 0)
+      {
+        break;
+      }
+      left_p++;
+    }
+
+    if (left_p == left_end_p)
+    {
+      increase_result = false;
+    }
   }
 
   uint32_t size = left_size - crop_size;
@@ -1394,7 +1466,12 @@ ecma_big_uint_shift_right (ecma_extended_primitive_t *left_value_p,  /**< left B
   if (shift_right == 0)
   {
     memcpy (ECMA_BIGINT_GET_DIGITS (result_value_p, 0), ECMA_BIGINT_GET_DIGITS (left_value_p, crop_size), size);
-    return result_value_p;
+
+    if (JERRY_LIKELY (!increase_result))
+    {
+      return result_value_p;
+    }
+    return ecma_big_uint_increase_result (result_value_p);
   }
 
   ecma_bigint_digit_t *left_p = ECMA_BIGINT_GET_DIGITS (left_value_p, left_size);
@@ -1410,71 +1487,91 @@ ecma_big_uint_shift_right (ecma_extended_primitive_t *left_value_p,  /**< left B
   }
   while (result_p > end_p);
 
-  return result_value_p;
+  if (JERRY_LIKELY (!increase_result))
+  {
+    return result_value_p;
+  }
+  return ecma_big_uint_increase_result (result_value_p);
 } /* ecma_big_uint_shift_right */
 
-/**
- * Helper function for bitwise operations which drops leading zeroes
- *
- * @return ecma BigInt value or ECMA_VALUE_ERROR
- *         Returned value must be freed with ecma_free_value.
- */
-static ecma_extended_primitive_t *
-ecma_big_uint_normalize_result (ecma_extended_primitive_t *value_p, /**< BigUInt value */
-                                ecma_bigint_digit_t *last_digit_p) /**< points to the end of BigUInt */
-{
-  JERRY_ASSERT (last_digit_p[-1] == 0);
-
-  ecma_bigint_digit_t *first_digit_p = ECMA_BIGINT_GET_DIGITS (value_p, 0);
-
-  do
-  {
-    --last_digit_p;
-  }
-  while (last_digit_p > first_digit_p && last_digit_p[-1] == 0);
-
-  return ecma_big_uint_shrink_value (value_p, (uint32_t) ((uint8_t *) last_digit_p - (uint8_t *) first_digit_p));
-} /* ecma_big_uint_normalize_result */
+#if ENABLED (JERRY_ESNEXT)
 
 /**
- * Helper function for bitwise operations which increases the result by 1
+ * Compute the left value raised to the power of right value
  *
- * @return new BigInt value, NULL on error
+ * return new BigUInt value, NULL on error
  */
-static ecma_extended_primitive_t *
-ecma_big_uint_increase_result (ecma_extended_primitive_t *value_p) /**< BigUInt value */
+ecma_extended_primitive_t *
+ecma_big_uint_pow (ecma_extended_primitive_t *left_value_p, /**< left BigUInt value */
+                   uint32_t right_value) /**< power value */
 {
-  uint32_t size = ECMA_BIGINT_GET_SIZE (value_p);
+  ecma_extended_primitive_t *result_p = ECMA_BIGINT_NUMBER_IS_ODD (right_value) ? left_value_p : NULL;
+  ecma_extended_primitive_t *square_p = left_value_p;
 
-  JERRY_ASSERT (size > 0);
+  JERRY_ASSERT (right_value >= 2);
 
-  ecma_bigint_digit_t *first_digit_p = ECMA_BIGINT_GET_DIGITS (value_p, 0);
-  ecma_bigint_digit_t *last_digit_p = ECMA_BIGINT_GET_DIGITS (value_p, size);
-
-  while (*first_digit_p == ~((ecma_bigint_digit_t) 0))
+  while (true)
   {
-    *first_digit_p++ = 0;
+    ecma_extended_primitive_t *new_square_p = ecma_big_uint_mul (square_p, square_p);
 
-    if (first_digit_p == last_digit_p)
+    if (JERRY_UNLIKELY (new_square_p == NULL))
     {
-      return ecma_big_uint_extend (value_p, 1);
+      if (result_p != NULL && result_p != left_value_p)
+      {
+        ecma_deref_bigint (result_p);
+      }
+      result_p = NULL;
+      break;
+    }
+
+    if (square_p != left_value_p)
+    {
+      ecma_deref_bigint (square_p);
+    }
+
+    square_p = new_square_p;
+    right_value >>= 1;
+
+    if (ECMA_BIGINT_NUMBER_IS_ODD (right_value))
+    {
+      if (result_p != NULL)
+      {
+        ecma_extended_primitive_t *new_result_p = ecma_big_uint_mul (square_p, result_p);
+
+        if (result_p != left_value_p)
+        {
+          ecma_deref_bigint (result_p);
+        }
+
+        result_p = new_result_p;
+      }
+      else
+      {
+        ecma_ref_extended_primitive (square_p);
+        result_p = square_p;
+      }
+
+      if (JERRY_UNLIKELY (result_p == NULL) || right_value == 1)
+      {
+        break;
+      }
     }
   }
 
-  (*first_digit_p)++;
-
-  if (last_digit_p[-1] != 0)
+  if (square_p != left_value_p)
   {
-    return value_p;
+    ecma_deref_bigint (square_p);
   }
 
-  return ecma_big_uint_normalize_result (value_p, last_digit_p);
-} /* ecma_big_uint_increase_result */
+  return result_p;
+} /* ecma_big_uint_pow */
+
+#endif /* ENABLED (JERRY_ESNEXT) */
 
 /**
  * Perform bitwise operations on two BigUInt numbers
  *
- * return new BigInt value, NULL on error
+ * return new BigUInt value, NULL on error
  */
 ecma_extended_primitive_t *
 ecma_big_uint_bitwise_op (uint32_t operation_and_options, /**< bitwise operation type and options */

jerry-core/ecma/operations/ecma-big-uint.h

@@ -59,6 +59,11 @@ typedef uint64_t ecma_bigint_two_digits_t;
 #define ECMA_BIGINT_HIGH_DIGIT(digit) \
   (((ecma_bigint_two_digits_t) digit) << (8 * sizeof (ecma_bigint_digit_t)))
 
+/**
+ * Tells whether a number (usually a digit or uint32_t value) is an odd number.
+ */
+#define ECMA_BIGINT_NUMBER_IS_ODD(number) ((number & 0x1) != 0)
+
 /**
  * Bitwise operation types.
  */
@@ -117,7 +122,12 @@ ecma_extended_primitive_t *ecma_big_uint_div_mod (ecma_extended_primitive_t *div
                                                   bool is_mod);
 
 ecma_extended_primitive_t *ecma_big_uint_shift_left (ecma_extended_primitive_t *left_value_p, uint32_t right_value);
-ecma_extended_primitive_t *ecma_big_uint_shift_right (ecma_extended_primitive_t *left_value_p, uint32_t right_value);
+ecma_extended_primitive_t *ecma_big_uint_shift_right (ecma_extended_primitive_t *left_value_p, uint32_t right_value,
+                                                      bool increase_result);
+
+#if ENABLED (JERRY_ESNEXT)
+ecma_extended_primitive_t *ecma_big_uint_pow (ecma_extended_primitive_t *left_value_p, uint32_t right_value);
+#endif /* ENABLED (JERRY_ESNEXT) */
 
 ecma_extended_primitive_t *ecma_big_uint_bitwise_op (uint32_t operation_and_options,
                                                      ecma_extended_primitive_t *left_value_p,

jerry-core/ecma/operations/ecma-bigint.c

@@ -113,11 +113,7 @@ ecma_bigint_parse_string (const lit_utf8_byte_t *string_p, /**< string represena
   }
   else if (size == 0)
   {
-    if (options & ECMA_BIGINT_PARSE_DISALLOW_SYNTAX_ERROR)
-    {
-      return ECMA_VALUE_FALSE;
-    }
-    return ecma_raise_syntax_error (ECMA_ERR_MSG ("BigInt cannot be constructed from empty string"));
+    return ECMA_BIGINT_ZERO;
   }
 
   const lit_utf8_byte_t *string_end_p = string_p + size;
@@ -289,7 +285,7 @@ ecma_bigint_number_to_digits (ecma_number_t number, /**< ecma number */
 
   ecma_number_unpack (number, NULL, &biased_exp, &fraction);
 
-  if (biased_exp == 0)
+  if (biased_exp == 0 && fraction == 0)
   {
     /* Number is zero. */
     return ECMA_BIGINT_NUMBER_TO_DIGITS_SET_DIGITS (0);
@@ -784,6 +780,11 @@ ecma_bigint_is_equal_to_number (ecma_value_t left_value, /**< left BigInt value
  */
 #define ECMA_BIGINT_TO_SIGN(value) (1 - (((int) (value)) << 1))
 
+/**
+ * Convert 0 to -1, and 1 to 1. Useful for getting negated sign.
+ */
+#define ECMA_BIGINT_TO_NEGATED_SIGN(value) (-1 + (((int) (value)) << 1))
+
 /**
  * Compare two BigInt values
  *
@@ -795,10 +796,26 @@ ecma_bigint_compare_to_bigint (ecma_value_t left_value, /**< left BigInt value *
 {
   JERRY_ASSERT (ecma_is_value_bigint (left_value) && ecma_is_value_bigint (right_value));
 
-  ecma_extended_primitive_t *left_p = ecma_get_extended_primitive_from_value (left_value);
-  ecma_extended_primitive_t *right_p = ecma_get_extended_primitive_from_value (right_value);
+  if (left_value == ECMA_BIGINT_ZERO)
+  {
+    if (right_value == ECMA_BIGINT_ZERO)
+    {
+      return 0;
+    }
 
+    ecma_extended_primitive_t *right_p = ecma_get_extended_primitive_from_value (right_value);
+    return ECMA_BIGINT_TO_NEGATED_SIGN (right_p->u.bigint_sign_and_size & ECMA_BIGINT_SIGN);
+  }
+
+  ecma_extended_primitive_t *left_p = ecma_get_extended_primitive_from_value (left_value);
   uint32_t left_sign = left_p->u.bigint_sign_and_size & ECMA_BIGINT_SIGN;
+
+  if (right_value == ECMA_BIGINT_ZERO)
+  {
+    return ECMA_BIGINT_TO_SIGN (left_sign);
+  }
+
+  ecma_extended_primitive_t *right_p = ecma_get_extended_primitive_from_value (right_value);
   uint32_t right_sign = right_p->u.bigint_sign_and_size & ECMA_BIGINT_SIGN;
 
   if ((left_sign ^ right_sign) != 0)
@@ -806,7 +823,12 @@ ecma_bigint_compare_to_bigint (ecma_value_t left_value, /**< left BigInt value *
     return ECMA_BIGINT_TO_SIGN (left_sign);
   }
 
-  return ecma_big_uint_compare (left_p, right_p);
+  if (left_sign == 0)
+  {
+    return ecma_big_uint_compare (left_p, right_p);
+  }
+
+  return -ecma_big_uint_compare (left_p, right_p);
 } /* ecma_bigint_compare_to_bigint */
 
 /**
@@ -1250,6 +1272,7 @@ ecma_bigint_shift (ecma_value_t left_value, /**< left BigInt value */
 
   ecma_extended_primitive_t *result_p;
   ecma_bigint_digit_t shift = ECMA_BIGINT_GET_LAST_DIGIT (right_p, sizeof (ecma_bigint_digit_t));
+  uint32_t left_sign = left_p->u.bigint_sign_and_size & ECMA_BIGINT_SIGN;
 
   if (is_left)
   {
@@ -1257,7 +1280,10 @@ ecma_bigint_shift (ecma_value_t left_value, /**< left BigInt value */
   }
   else
   {
-    result_p = ecma_big_uint_shift_right (left_p, shift);
+    /* -x >> y == ~(x - 1) >> y == ~((x - 1) >> y) == -(((x - 1) >> y) + 1)
+     * When a non-zero bit is shifted out: (x - 1) >> y == x >> y, so the formula is -((x >> y) + 1)
+     * When only zero bits are shifted out: (((x - 1) >> y) + 1) == x >> y so the formula is: -(x >> y) */
+    result_p = ecma_big_uint_shift_right (left_p, shift, left_sign != 0);
 
     if (result_p == ECMA_BIGINT_POINTER_TO_ZERO)
     {
@@ -1270,10 +1296,102 @@ ecma_bigint_shift (ecma_value_t left_value, /**< left BigInt value */
     return ecma_bigint_raise_memory_error ();
   }
 
-  result_p->u.bigint_sign_and_size |= left_p->u.bigint_sign_and_size & ECMA_BIGINT_SIGN;
+  result_p->u.bigint_sign_and_size |= left_sign;
   return ecma_make_extended_primitive_value (result_p, ECMA_TYPE_BIGINT);
 } /* ecma_bigint_shift */
 
+#if ENABLED (JERRY_ESNEXT)
+
+/**
+ * Compute the left value raised to the power of right value
+ *
+ * @return ecma BigInt value or ECMA_VALUE_ERROR
+ *         Returned value must be freed with ecma_free_value.
+ */
+ecma_value_t
+ecma_bigint_pow (ecma_value_t left_value, /**< left BigInt value */
+                 ecma_value_t right_value) /**< right BigInt value */
+{
+  JERRY_ASSERT (ecma_is_value_bigint (left_value) && ecma_is_value_bigint (right_value));
+
+  if (right_value == ECMA_BIGINT_ZERO)
+  {
+    return ecma_bigint_create_from_digit (1, false);
+  }
+
+  ecma_extended_primitive_t *right_p = ecma_get_extended_primitive_from_value (right_value);
+
+  if (right_p->u.bigint_sign_and_size & ECMA_BIGINT_SIGN)
+  {
+    return ecma_raise_range_error (ECMA_ERR_MSG ("Negative exponent is not allowed for BigInts"));
+  }
+
+  if (left_value == ECMA_BIGINT_ZERO)
+  {
+    return ECMA_BIGINT_ZERO;
+  }
+
+  ecma_extended_primitive_t *left_p = ecma_get_extended_primitive_from_value (left_value);
+  ecma_bigint_digit_t base = 0;
+
+  if (ECMA_BIGINT_GET_SIZE (left_p) == sizeof (ecma_bigint_digit_t))
+  {
+    base = *ECMA_BIGINT_GET_DIGITS (left_p, 0);
+
+    JERRY_ASSERT (base != 0);
+
+    if (base == 1)
+    {
+      if (!(left_p->u.bigint_sign_and_size & ECMA_BIGINT_SIGN)
+          || ECMA_BIGINT_NUMBER_IS_ODD (*ECMA_BIGINT_GET_DIGITS (right_p, 0)))
+      {
+        ecma_ref_extended_primitive (left_p);
+        return left_value;
+      }
+
+      return ecma_bigint_create_from_digit (1, false);
+    }
+  }
+
+  if (JERRY_UNLIKELY (ECMA_BIGINT_GET_SIZE (right_p) > sizeof (ecma_bigint_digit_t)))
+  {
+    return ecma_bigint_raise_memory_error ();
+  }
+
+  ecma_bigint_digit_t power = *ECMA_BIGINT_GET_DIGITS (right_p, 0);
+
+  if (power == 1)
+  {
+    ecma_ref_extended_primitive (left_p);
+    return left_value;
+  }
+
+  ecma_extended_primitive_t *result_p;
+
+  if (base == 2)
+  {
+    result_p = ecma_big_uint_shift_left (left_p, power - 1);
+  }
+  else
+  {
+    result_p = ecma_big_uint_pow (left_p, power);
+  }
+
+  if (JERRY_UNLIKELY (result_p == NULL))
+  {
+    return ecma_bigint_raise_memory_error ();
+  }
+
+  if ((left_p->u.bigint_sign_and_size & ECMA_BIGINT_SIGN) && ECMA_BIGINT_NUMBER_IS_ODD (power))
+  {
+    result_p->u.bigint_sign_and_size |= ECMA_BIGINT_SIGN;
+  }
+
+  return ecma_make_extended_primitive_value (result_p, ECMA_TYPE_BIGINT);
+} /* ecma_bigint_pow */
+
+#endif /* ENABLED (JERRY_ESNEXT) */
+
 /**
  * Convert the result to an ecma value
  *

jerry-core/ecma/operations/ecma-bigint.h

@@ -69,6 +69,9 @@ ecma_value_t ecma_bigint_add_sub (ecma_value_t left_value, ecma_value_t right_va
 ecma_value_t ecma_bigint_mul (ecma_value_t left_value, ecma_value_t right_value);
 ecma_value_t ecma_bigint_div_mod (ecma_value_t left_value, ecma_value_t right_value, bool is_mod);
 ecma_value_t ecma_bigint_shift (ecma_value_t left_value, ecma_value_t right_value, bool is_left);
+#if ENABLED (JERRY_ESNEXT)
+ecma_value_t ecma_bigint_pow (ecma_value_t left_value, ecma_value_t right_value);
+#endif /* ENABLED (JERRY_ESNEXT) */
 
 ecma_value_t ecma_bigint_and (ecma_value_t left_value, ecma_value_t right_value);
 ecma_value_t ecma_bigint_or (ecma_value_t left_value, ecma_value_t right_value);

jerry-core/ecma/operations/ecma-comparison.c

@@ -92,9 +92,9 @@ ecma_op_abstract_equality_compare (ecma_value_t x, /**< first operand */
     }
 
     /* Swap values. */
-    ecma_value_t tmp = x;
-    x = y;
-    y = tmp;
+    x ^= y;
+    y ^= x;
+    x ^= y;
   }
 
   if (ecma_is_value_string (x))
@@ -127,9 +127,9 @@ ecma_op_abstract_equality_compare (ecma_value_t x, /**< first operand */
     }
 
     /* Swap values. */
-    ecma_value_t tmp = x;
-    x = y;
-    y = tmp;
+    x ^= y;
+    y ^= x;
+    x ^= y;
   }
 
   if (ecma_is_value_boolean (y))
@@ -192,7 +192,10 @@ ecma_op_abstract_equality_compare (ecma_value_t x, /**< first operand */
       return ecma_make_boolean_value (ecma_bigint_is_equal_to_number (x, ecma_get_number_from_value (y)));
     }
 
-    return ECMA_VALUE_FALSE;
+    /* Swap values. */
+    x ^= y;
+    y ^= x;
+    x ^= y;
   }
 #endif /* ENABLED (JERRY_BUILTIN_BIGINT) */
 

jerry-core/parser/js/js-lexer.c

@@ -1474,7 +1474,7 @@ lexer_parse_number (parser_context_t *context_p) /**< context */
 #endif /* ENABLED (JERRY_BUILTIN_BIGINT) */
 
   length = (size_t) (source_p - context_p->source_p);
-  if (length > PARSER_MAXIMUM_IDENT_LENGTH)
+  if (length > PARSER_MAXIMUM_STRING_LENGTH)
   {
     parser_raise_error (context_p, PARSER_ERR_NUMBER_TOO_LONG);
   }

jerry-core/parser/js/js-parser-expr.c

@@ -1883,6 +1883,12 @@ parser_parse_unary_expression (parser_context_t *context_p, /**< context */
             {
               is_negative_number = !is_negative_number;
             }
+#if ENABLED (JERRY_BUILTIN_BIGINT)
+            else if (JERRY_LIKELY (context_p->token.extra_value == LEXER_NUMBER_BIGINT))
+            {
+              break;
+            }
+#endif /* ENABLED (JERRY_BUILTIN_BIGINT) */
             parser_stack_pop_uint8 (context_p);
           }
           while (context_p->stack_top_uint8 == LEXER_PLUS

jerry-core/vm/opcodes-ecma-arithmetics.c

@@ -134,11 +134,13 @@ do_number_arithmetic (number_arithmetic_op op, /**< number arithmetic operation
         ret_value = ecma_bigint_div_mod (left_value, right_value, true);
         break;
       }
-      default:
+#if ENABLED (JERRY_ESNEXT)
+      case NUMBER_ARITHMETIC_EXPONENTIATION:
       {
-        ret_value = ecma_raise_common_error (ECMA_ERR_MSG ("Not supported BigInt operation"));
+        ret_value = ecma_bigint_pow (left_value, right_value);
         break;
       }
+#endif /* ENABLED (JERRY_ESNEXT) */
     }
 
     ecma_free_value (left_value);