Precompute power if both arguments are constants (#2330)

Author: MaxGraey

src/compiler.ts

@@ -5187,6 +5187,22 @@ export class Compiler extends DiagnosticEmitter {
       }
       case TypeKind.I32:
       case TypeKind.U32: {
+        if (this.options.willOptimize) {
+          // Precompute power if LHS and RHS constants
+          // TODO: move this optimization to AIR
+          if (
+            getExpressionId(leftExpr) == ExpressionId.Const &&
+            getExpressionId(rightExpr) == ExpressionId.Const
+          ) {
+            let leftValue = getConstValueI32(leftExpr);
+            let rightValue = getConstValueI32(rightExpr);
+            this.currentType = type;
+            return module.i32(i64_low(i64_pow(
+              i64_new(leftValue),
+              i64_new(rightValue)
+            )));
+          }
+        }
         let instance = this.i32PowInstance;
         if (!instance) {
           let prototype = this.program.lookup(CommonNames.ipow32);
@@ -5213,6 +5229,20 @@ export class Compiler extends DiagnosticEmitter {
       }
       case TypeKind.I64:
       case TypeKind.U64: {
+        if (this.options.willOptimize) {
+          // Precompute power if LHS and RHS constants
+          // TODO: move this optimization to AIR
+          if (
+            getExpressionId(leftExpr) == ExpressionId.Const &&
+            getExpressionId(rightExpr) == ExpressionId.Const
+          ) {
+            let leftValue = i64_new(getConstValueI64Low(leftExpr), getConstValueI64High(leftExpr));
+            let rightValue = i64_new(getConstValueI64Low(rightExpr), getConstValueI64High(rightExpr));
+            let result = i64_pow(leftValue, rightValue);
+            this.currentType = type;
+            return module.i64(i64_low(result), i64_high(result));
+          }
+        }
         let instance = this.i64PowInstance;
         if (!instance) {
           let prototype = this.program.lookup(CommonNames.ipow64);
@@ -5234,6 +5264,30 @@ export class Compiler extends DiagnosticEmitter {
       case TypeKind.ISIZE:
       case TypeKind.USIZE: {
         let isWasm64 = this.options.isWasm64;
+        if (this.options.willOptimize) {
+          // Precompute power if LHS and RHS constants
+          // TODO: move this optimization to AIR
+          if (
+            getExpressionId(leftExpr) == ExpressionId.Const &&
+            getExpressionId(rightExpr) == ExpressionId.Const
+          ) {
+            if (isWasm64) {
+              let leftValue = i64_new(getConstValueI64Low(leftExpr), getConstValueI64High(leftExpr));
+              let rightValue = i64_new(getConstValueI64Low(rightExpr), getConstValueI64High(rightExpr));
+              let result = i64_pow(leftValue, rightValue);
+              this.currentType = type;
+              return module.i64(i64_low(result), i64_high(result));
+            } else {
+              let leftValue = getConstValueI32(leftExpr);
+              let rightValue = getConstValueI32(rightExpr);
+              this.currentType = type;
+              return module.i32(i64_low(i64_pow(
+                i64_new(leftValue),
+                i64_new(rightValue)
+              )));
+            }
+          }
+        }
         let instance = isWasm64 ? this.i64PowInstance : this.i32PowInstance;
         if (!instance) {
           let prototype = this.program.lookup(isWasm64 ? CommonNames.ipow64 : CommonNames.ipow32);
@@ -5258,6 +5312,19 @@ export class Compiler extends DiagnosticEmitter {
         return this.makeCallDirect(instance, [ leftExpr, rightExpr ], reportNode);
       }
       case TypeKind.F32: {
+        if (this.options.willOptimize) {
+          // Precompute power if LHS and RHS constants
+          // TODO: move this optimization to AIR
+          if (
+            getExpressionId(leftExpr) == ExpressionId.Const &&
+            getExpressionId(rightExpr) == ExpressionId.Const
+          ) {
+            let leftValue = getConstValueF32(leftExpr);
+            let rightValue = getConstValueF32(rightExpr);
+            this.currentType = type;
+            return module.f32(f32(Math.pow(leftValue, rightValue)));
+          }
+        }
         let instance = this.f32PowInstance;
         if (!instance) {
           let namespace = this.program.lookup(CommonNames.Mathf);
@@ -5287,6 +5354,19 @@ export class Compiler extends DiagnosticEmitter {
       }
       // Math.pow otherwise (result is f64)
       case TypeKind.F64: {
+        if (this.options.willOptimize) {
+          // Precompute power if LHS and RHS constants
+          // TODO: move this optimization to AIR
+          if (
+            getExpressionId(leftExpr) == ExpressionId.Const &&
+            getExpressionId(rightExpr) == ExpressionId.Const
+          ) {
+            let leftValue = getConstValueF64(leftExpr);
+            let rightValue = getConstValueF64(rightExpr);
+            this.currentType = type;
+            return module.f64(Math.pow(leftValue, rightValue));
+          }
+        }
         let instance = this.f64PowInstance;
         if (!instance) {
           let namespace = this.program.lookup(CommonNames.Math);