Implement experimental exponentiation operator

src/compiler/typer.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/base/flags.h"
 #include "src/bootstrapper.h"
 #include "src/compiler/graph-reducer.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-properties.h"
@@ skipping 332 matching lines @@
   static Type* ToNumber(Type*, Typer*);
   static Type* ToString(Type*, Typer*);
   static Type* NumberToInt32(Type*, Typer*);
   static Type* NumberToUint32(Type*, Typer*);
 
   static Type* JSAddRanger(Type::RangeType*, Type::RangeType*, Typer*);
   static Type* JSSubtractRanger(Type::RangeType*, Type::RangeType*, Typer*);
   static Type* JSMultiplyRanger(Type::RangeType*, Type::RangeType*, Typer*);
   static Type* JSDivideRanger(Type::RangeType*, Type::RangeType*, Typer*);
   static Type* JSModulusRanger(Type::RangeType*, Type::RangeType*, Typer*);
+  static Type* JSExponentiateRanger(Type::RangeType*, Type::RangeType*, Typer*);
 
   static ComparisonOutcome JSCompareTyper(Type*, Type*, Typer*);
 
 #define DECLARE_METHOD(x) static Type* x##Typer(Type*, Type*, Typer*);
   JS_SIMPLE_BINOP_LIST(DECLARE_METHOD)
 #undef DECLARE_METHOD
 
   static Type* JSUnaryNotTyper(Type*, Typer*);
   static Type* JSLoadPropertyTyper(Type*, Type*, Typer*);
   static Type* JSCallFunctionTyper(Type*, Typer*);
@@ skipping 853 matching lines @@
 
   lhs = Rangify(lhs, t);
   rhs = Rangify(rhs, t);
   if (lhs->IsRange() && rhs->IsRange()) {
     return JSModulusRanger(lhs->AsRange(), rhs->AsRange(), t);
   }
   return Type::OrderedNumber();
 }
 
 
+Type* Typer::Visitor::JSExponentiateRanger(Type::RangeType* lhs,
+                                           Type::RangeType* rhs, Typer* t) {
+  double lmin = lhs->Min();
+  double lmax = lhs->Max();
+  double rmin = rhs->Min();
+  double rmax = rhs->Max();
+
+  if (lmin > 0.0) {
+    // +x ** -y : epsilon...1
+    if (rmax < 0.0) return Type::Range(0.0, 1.0, t->zone());
+
+    // +x ** +y : epsilon...infinity
+    if (rmin > 0.0) return Type::Range(0.0, +V8_INFINITY, t->zone());
+  } else if (lmax < 0.0) {
+    // -x ** -y : -1.0...1.0
+    if (rmax < 0.0) return Type::Range(-1.0, 1.0, t->zone());
+  }
+
+  // pow(lmin, rmax) does not limit range by much.
+  return Type::Number();
+}
+
+
+Type* Typer::Visitor::JSExponentiateTyper(Type* lhs, Type* rhs, Typer* t) {
+  lhs = ToNumber(lhs, t);
+  rhs = ToNumber(rhs, t);
+
+  // x ** NaN|undefined : NaN
+  if (rhs->Is(Type::NaN())) return Type::NaN();
+
+  // x ** 0|false|null : 1
+  if (rhs->Is(t->singleton_zero)) return t->singleton_one;
+
+  // NaN ** x [~0] : NaN
+  if (lhs->Is(Type::NaN())) return Type::NaN();
+
+  // 0|false|null ** x [~0] : 0
+  if (lhs->Is(t->singleton_zero)) return t->singleton_zero;
+
+  lhs = Rangify(lhs, t);
+  rhs = Rangify(rhs, t);
+  if (lhs->IsRange() && rhs->IsRange()) {
+    return JSExponentiateRanger(lhs->AsRange(), rhs->AsRange(), t);
+  }
+  return Type::Number();
+}
+
+
 // JS unary operators.
 
 
 Type* Typer::Visitor::JSUnaryNotTyper(Type* type, Typer* t) {
   return Invert(ToBoolean(type, t), t);
 }
 
 
 Bounds Typer::Visitor::TypeJSUnaryNot(Node* node) {
   return TypeUnaryOp(node, JSUnaryNotTyper);
@@ skipping 948 matching lines @@
       TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
     }
   }
   return Type::Constant(value, zone());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8