Use integer power for integer types

src/common.ts

@@ -203,6 +203,8 @@ export namespace CommonNames {
   // runtime
   export const abort = "abort";
   export const pow = "pow";
+  export const ipow32 = "ipow32";
+  export const ipow64 = "ipow64";
   export const mod = "mod";
   export const alloc = "__alloc";
   export const realloc = "__realloc";

src/compiler.ts

@@ -3687,6 +3687,8 @@ export class Compiler extends DiagnosticEmitter {
   private f64ModInstance: Function | null = null;
   private f32PowInstance: Function | null = null;
   private f64PowInstance: Function | null = null;
+  private i32PowInstance: Function | null = null;
+  private i64PowInstance: Function | null = null;
 
   private compileBinaryExpression(
     expression: BinaryExpression,
@@ -4620,8 +4622,50 @@ export class Compiler extends DiagnosticEmitter {
         let targetType = leftType;
         let instance: Function | null;
 
-        // Mathf.pow if lhs is f32 (result is f32)
-        if (this.currentType.kind == TypeKind.F32) {
+        if ((this.currentType.kind == TypeKind.I32 || this.currentType.kind == TypeKind.U32)) {
+          let type = this.currentType.kind == TypeKind.I32 ? Type.i32 : Type.u32;
+
+          rightExpr = this.compileExpression(right, type, Constraints.CONV_IMPLICIT);
+          rightType = this.currentType;
+          instance  = this.i32PowInstance;
+
+          if (!instance) {
+            let prototype = this.program.lookupGlobal(CommonNames.ipow32);
+            if (!prototype) {
+              this.error(
+                DiagnosticCode.Cannot_find_name_0,
+                expression.range, "ipow32"
+              );
+              expr = module.unreachable();
+              break;
+            }
+            assert(prototype.kind == ElementKind.FUNCTION_PROTOTYPE);
+            this.i32PowInstance = instance = this.resolver.resolveFunction(<FunctionPrototype>prototype, null);
+          }
+
+        } else if (this.currentType.kind == TypeKind.I64 || this.currentType.kind == TypeKind.U64) {
+
+          let type = this.currentType.kind == TypeKind.I64 ? Type.i64 : Type.u64;
+
+          rightExpr = this.compileExpression(right, type, Constraints.CONV_IMPLICIT);
+          rightType = this.currentType;
+          instance  = this.i64PowInstance;
+
+          if (!instance) {
+            let prototype = this.program.lookupGlobal(CommonNames.ipow64);
+            if (!prototype) {
+              this.error(
+                DiagnosticCode.Cannot_find_name_0,
+                expression.range, "ipow64"
+              );
+              expr = module.unreachable();
+              break;
+            }
+            assert(prototype.kind == ElementKind.FUNCTION_PROTOTYPE);
+            this.i64PowInstance = instance = this.resolver.resolveFunction(<FunctionPrototype>prototype, null);
+          }
+          // Mathf.pow if lhs is f32 (result is f32)
+        } else if (this.currentType.kind == TypeKind.F32) {
           rightExpr = this.compileExpression(right, Type.f32, Constraints.CONV_IMPLICIT);
           rightType = this.currentType;
           instance = this.f32PowInstance;

src/glue/js/i64.d.ts

@@ -15,6 +15,7 @@ declare function i64_high(value: i64): i32;
 declare function i64_add(left: i64, right: i64): i64;
 declare function i64_sub(left: i64, right: i64): i64;
 declare function i64_mul(left: i64, right: i64): i64;
+declare function i64_pow(left: i64, right: i64): i64;
 declare function i64_div(left: i64, right: i64): i64;
 declare function i64_div_u(left: i64, right: i64): i64;
 declare function i64_rem(left: i64, right: i64): i64;

src/glue/js/i64.js

@@ -33,6 +33,26 @@ global.i64_mul = function(left, right) {
   return left.mul(right);
 };
 
+global.i64_pow = function(left, right) {
+  var rightHi = right.high;
+  if (rightHi < 0) return Long.ZERO;
+  var rightLo = right.low;
+  if (!rightHi) {
+    if (rightLo == 0) return Long.ONE;
+    if (rightLo == 1) return left;
+    if (rightLo == 2) return left.mul(left);
+  }
+  var result = Long.ONE;
+  while (rightLo | rightHi) {
+    if (rightLo & 1) result = result.mul(left);
+    right = right.shru(1);
+    left  = left.mul(left);
+    rightLo = right.low;
+    rightHi = right.high;
+  }
+  return result;
+};
+
 global.i64_div = function(left, right) {
   return left.div(right);
 };

src/glue/wasm/i64.ts

@@ -47,6 +47,21 @@ function i64_mul(left: i64, right: i64): i64 {
   return left * right;
 }
 
+// @ts-ignore: decorator
+@global
+function i64_pow(left: i64, right: i64): i64 {
+  if (right <= 0) return i64(right == 0);
+  if (right == 1) return left;
+  if (right == 2) return left * left;
+  var result: i64 = 1;
+  while (right) {
+    if (right & 1) result *= left;
+    right >>>= 1;
+    left *= left;
+  }
+  return result;
+}
+
 // @ts-ignore: decorator
 @global
 function i64_div(left: i64, right: i64): i64 {

std/assembly/math.ts

@@ -3004,13 +3004,9 @@ export namespace NativeMathf {
 export function ipow32(x: i32, e: i32): i32 {
   var out = 1;
   if (ASC_SHRINK_LEVEL < 1) {
-    if (e < 0) return 0;
-
-    switch (e) {
-      case 0: return 1;
-      case 1: return x;
-      case 2: return x * x;
-    }
+    if (e <= 0) return i32(e == 0);
+    if (e == 1) return x;
+    if (e == 2) return x * x;
 
     let log = 32 - clz(e);
     if (log <= 5) {
@@ -3019,22 +3015,22 @@ export function ipow32(x: i32, e: i32): i32 {
       switch (log) {
         case 5: {
           if (e & 1) out *= x;
-          e >>= 1;
+          e >>>= 1;
           x *= x;
         }
         case 4: {
           if (e & 1) out *= x;
-          e >>= 1;
+          e >>>= 1;
           x *= x;
         }
         case 3: {
           if (e & 1) out *= x;
-          e >>= 1;
+          e >>>= 1;
           x *= x;
         }
         case 2: {
           if (e & 1) out *= x;
-          e >>= 1;
+          e >>>= 1;
           x *= x;
         }
         case 1: {
@@ -3045,52 +3041,49 @@ export function ipow32(x: i32, e: i32): i32 {
     }
   }
 
-  while (e > 0) {
+  while (e) {
     if (e & 1) out *= x;
-    e >>= 1;
+    e >>>= 1;
     x *= x;
   }
   return out;
 }
 
-export function ipow64(x: i64, e: i32): i64 {
+export function ipow64(x: i64, e: i64): i64 {
   var out: i64 = 1;
   if (ASC_SHRINK_LEVEL < 1) {
-    if (e < 0) return 0;
-    switch (e) {
-      case 0: return 1;
-      case 1: return x;
-      case 2: return x * x;
-    }
+    if (e <= 0) return i64(e == 0);
+    if (e == 1) return x;
+    if (e == 2) return x * x;
 
-    let log = 32 - clz(e);
+    let log = 64 - <i32>clz(e);
     if (log <= 6) {
       // 64 = 2 ^ 6, so need only six cases.
       // But some extra cases needs for properly overflowing
       switch (log) {
         case 6: {
           if (e & 1) out *= x;
-          e >>= 1;
+          e >>>= 1;
           x *= x;
         }
         case 5: {
           if (e & 1) out *= x;
-          e >>= 1;
+          e >>>= 1;
           x *= x;
         }
         case 4: {
           if (e & 1) out *= x;
-          e >>= 1;
+          e >>>= 1;
           x *= x;
         }
         case 3: {
           if (e & 1) out *= x;
-          e >>= 1;
+          e >>>= 1;
           x *= x;
         }
         case 2: {
           if (e & 1) out *= x;
-          e >>= 1;
+          e >>>= 1;
           x *= x;
         }
         case 1: {
@@ -3100,35 +3093,10 @@ export function ipow64(x: i64, e: i32): i64 {
       return out;
     }
   }
-
-  while (e > 0) {
+  while (e) {
     if (e & 1) out *= x;
-    e >>= 1;
+    e >>>= 1;
     x *= x;
   }
   return out;
-}
-
-export function ipow32f(x: f32, e: i32): f32 {
-  var sign = e >> 31;
-  e = (e + sign) ^ sign; // abs(e)
-  var out: f32 = 1;
-  while (e) {
-    out *= select<f32>(x, 1.0, e & 1);
-    e >>= 1;
-    x *= x;
-  }
-  return sign ? <f32>1.0 / out : out;
-}
-
-export function ipow64f(x: f64, e: i32): f64 {
-  var sign = e >> 31;
-  e = (e + sign) ^ sign; // abs(e)
-  var out = 1.0;
-  while (e) {
-    out *= select(x, 1.0, e & 1);
-    e >>= 1;
-    x *= x;
-  }
-  return sign ? 1.0 / out : out;
-}
+}

tests/compiler/binary.optimized.wat

@@ -1,5 +1,6 @@
 (module
  (type $none_=>_none (func))
+ (type $i32_=>_i32 (func (param i32) (result i32)))
  (type $f32_=>_f32 (func (param f32) (result f32)))
  (type $f64_=>_f64 (func (param f64) (result f64)))
  (memory $0 1)
@@ -12,7 +13,39 @@
  (global $binary/F (mut f64) (f64.const 0))
  (export "memory" (memory $0))
  (start $~start)
- (func $~lib/math/NativeMathf.mod (; 0 ;) (param $0 f32) (result f32)
+ (func $~lib/math/ipow32 (; 0 ;) (param $0 i32) (result i32)
+  (local $1 i32)
+  (local $2 i32)
+  i32.const 1
+  local.set $1
+  i32.const 1
+  local.set $2
+  loop $while-continue|0
+   local.get $1
+   if
+    local.get $0
+    local.get $2
+    i32.mul
+    local.get $2
+    local.get $1
+    i32.const 1
+    i32.and
+    select
+    local.set $2
+    local.get $1
+    i32.const 1
+    i32.shr_u
+    local.set $1
+    local.get $0
+    local.get $0
+    i32.mul
+    local.set $0
+    br $while-continue|0
+   end
+  end
+  local.get $2
+ )
+ (func $~lib/math/NativeMathf.mod (; 1 ;) (param $0 f32) (result f32)
   (local $1 i32)
   (local $2 i32)
   (local $3 i32)
@@ -156,7 +189,7 @@
   local.get $0
   f32.mul
  )
- (func $~lib/math/NativeMath.mod (; 1 ;) (param $0 f64) (result f64)
+ (func $~lib/math/NativeMath.mod (; 2 ;) (param $0 f64) (result f64)
   (local $1 i64)
   (local $2 i64)
   (local $3 i64)
@@ -307,12 +340,15 @@
   local.get $0
   f64.mul
  )
- (func $start:binary (; 2 ;)
+ (func $start:binary (; 3 ;)
   global.get $binary/i
   i32.const 1
   i32.rem_s
   drop
   global.get $binary/i
+  call $~lib/math/ipow32
+  drop
+  global.get $binary/i
   i32.const 1
   i32.lt_s
   global.set $binary/b
@@ -349,8 +385,7 @@
   i32.rem_s
   global.set $binary/i
   global.get $binary/i
-  f64.convert_i32_s
-  i32.trunc_f64_s
+  call $~lib/math/ipow32
   global.set $binary/i
   global.get $binary/i
   i32.const 1
@@ -615,7 +650,7 @@
   call $~lib/math/NativeMath.mod
   global.set $binary/F
  )
- (func $~start (; 3 ;)
+ (func $~start (; 4 ;)
   call $start:binary
  )
 )