Route ModExp precompile in certain conditions (#8868)

Route ModExp precompile when base and modulus are even. This is to take advantage that Java and native are better in certain conditions, so they are routed appropriately to take advantage of each ones performance.

Author: lu-pinto

app/src/main/java/org/hyperledger/besu/cli/options/NativeLibraryOptions.java

@@ -53,7 +53,7 @@ public class NativeLibraryOptions {
           "Per default a native library is used for modexp. "
               + "If the Java implementation should be used instead, this option must be set to false",
       arity = "1")
-  private final Boolean nativeModExp = Boolean.TRUE;
+  private final Boolean nativeModExp = Boolean.FALSE;
 
   /** Default constructor. */
   NativeLibraryOptions() {}

evm/src/main/java/org/hyperledger/besu/evm/precompile/BigIntegerModularExponentiationPrecompiledContract.java

@@ -116,22 +116,33 @@ public PrecompileContractResult computePrecompile(
       return PrecompileContractResult.halt(
           null, Optional.of(ExceptionalHaltReason.PRECOMPILE_ERROR));
     }
+
+    // OPTIMIZATION: overwrite native setting for this case
+    if (LibArithmetic.ENABLED) {
+      final int baseOffset = clampedToInt(BASE_OFFSET);
+      final int baseLength = clampedToInt(length_of_BASE);
+      final int modulusOffset = clampedToInt(BASE_OFFSET + length_of_BASE + length_of_EXPONENT);
+      final int modulusLength = clampedToInt(length_of_MODULUS);
+      if ((extractLastByte(input, baseOffset, baseLength) & 1) != 1
+          && (extractLastByte(input, modulusOffset, modulusLength) & 1) != 1) {
+        return computeNative(input, modulusLength);
+      }
+    }
+
     if (useNative) {
-      return computeNative(input, length_of_MODULUS);
+      final int modulusLength = clampedToInt(length_of_MODULUS);
+      return computeNative(input, modulusLength);
     } else {
-      return computeDefault(input, length_of_BASE, length_of_EXPONENT, length_of_MODULUS);
+      final int baseLength = clampedToInt(length_of_BASE);
+      final int exponentLength = clampedToInt(length_of_EXPONENT);
+      final int modulusLength = clampedToInt(length_of_MODULUS);
+      return computeDefault(input, baseLength, exponentLength, modulusLength);
     }
   }
 
   @NotNull
   private PrecompileContractResult computeDefault(
-      final Bytes input,
-      final long length_of_BASE,
-      final long length_of_EXPONENT,
-      final long length_of_MODULUS) {
-    final int baseLength = clampedToInt(length_of_BASE);
-    final int exponentLength = clampedToInt(length_of_EXPONENT);
-    final int modulusLength = clampedToInt(length_of_MODULUS);
+      final Bytes input, final int baseLength, final int exponentLength, final int modulusLength) {
     // If baseLength and modulusLength are zero
     // we could have a massively overflowing exp because it wouldn't have been filtered out at the
     // gas cost phase
@@ -226,6 +237,16 @@ public static BigInteger extractParameter(final Bytes input, final int offset, f
     }
   }
 
+  private static byte extractLastByte(final Bytes input, final int offset, final int length) {
+    if (offset >= input.size() || length == 0) {
+      return 0;
+    } else if (offset + length <= input.size()) {
+      return input.get(offset + length - 1);
+    }
+    Bytes partial = input.slice(offset);
+    return partial.get(partial.size() - 1);
+  }
+
   /**
    * Extract parameter.
    *
@@ -257,8 +278,7 @@ private static long square(final long n) {
   }
 
   private PrecompileContractResult computeNative(
-      final @NotNull Bytes input, final long length_of_MODULUS) {
-    final int modulusLength = clampedToInt(length_of_MODULUS);
+      final @NotNull Bytes input, final int modulusLength) {
     final IntByReference o_len = new IntByReference(modulusLength);
 
     final byte[] result = new byte[modulusLength];