Inline mathematical constants

src/hydrogen.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 6617 matching lines @@
       HInstruction* length = Add<HConstant>(argument_count);
       HInstruction* checked_key = Add<HBoundsCheck>(key, length);
       result = New<HAccessArgumentsAt>(elements, length, checked_key);
     }
   }
   ast_context()->ReturnInstruction(result, expr->id());
   return true;
 }
 
 
+bool HOptimizedGraphBuilder::TryMathConstant(Property* expr) {
+  // Should be either .PI or ["PI"] etc
+  if (!expr->key()->IsPropertyName()) return false;
+  // Must refer to a variable called "Math" that is a global variable
+  VariableProxy* proxy = expr->obj()->AsVariableProxy();
+  if (proxy == NULL) return false;
+  if (!proxy->var()->IsUnallocated()) return false;
+  if (!(proxy->var()->name()->IsOneByteEqualTo(
+      STATIC_ASCII_VECTOR("Math")))) return false;
+  // The global Math property must still be
+  // pointing to the instance of MathConstructor object
+  if (!current_info()->has_global_object() ||
+       current_info()->global_object()->IsAccessCheckNeeded()) {
+    return false;
+  }
+  Handle<GlobalObject> global(current_info()->global_object());
+  LookupResult lookup(isolate());
+  global->Lookup(*proxy->var()->name(), &lookup);
+
+  if (!lookup.IsNormal() || !lookup.GetValue()->IsJSObject()) {
+    return false;
+  }
+
+  Handle<JSObject> mathObject(JSObject::cast(lookup.GetValue()));
+
+  if (!mathObject->map()->constructor()->IsJSFunction()) {
+    return false;
+  }
+
+  Handle<JSFunction> constructor(
+                        JSFunction::cast(mathObject->map()->constructor()));
+
+  // Users cannot set instance_class_name so this can be trusted
+  Handle<String> instance_name(
+      String::cast(constructor->shared()->instance_class_name()));
+  if (!instance_name->IsOneByteEqualTo(STATIC_ASCII_VECTOR("Math"))) {
+    return false;
+  }
+
+  Handle<String> name = expr->key()->AsLiteral()->AsPropertyName();
+  HConstant* constant = NULL;
+
+  if (name->IsOneByteEqualTo(STATIC_ASCII_VECTOR("SQRT2"))) {
+    constant = New<HConstant>(1.4142135623730951);
+  } else if (name->IsOneByteEqualTo(STATIC_ASCII_VECTOR("E"))) {
+    constant = New<HConstant>(2.718281828459045);
+  } else if (name->IsOneByteEqualTo(STATIC_ASCII_VECTOR("LN2"))) {
+    constant = New<HConstant>(0.6931471805599453);
+  } else if (name->IsOneByteEqualTo(STATIC_ASCII_VECTOR("LN10"))) {
+    constant = New<HConstant>(2.302585092994046);
+  } else if (name->IsOneByteEqualTo(STATIC_ASCII_VECTOR("LOG2E"))) {
+    constant = New<HConstant>(1.4426950408889634);
+  } else if (name->IsOneByteEqualTo(STATIC_ASCII_VECTOR("LOG10E"))) {
+    constant = New<HConstant>(0.4342944819032518);
+  } else if (name->IsOneByteEqualTo(STATIC_ASCII_VECTOR("PI"))) {
+    constant = New<HConstant>(3.141592653589793);
+  } else if (name->IsOneByteEqualTo(STATIC_ASCII_VECTOR("SQRT1_2"))) {
+    constant = New<HConstant>(0.7071067811865476);
+  }
+
+  if (constant != NULL) {
+    Handle<Map> map(current_info()->global_object()->map());
+    map->AddDependentCompilationInfo(DependentCode::kMathConstantGroup,
+                                     current_info());
+    ast_context()->ReturnInstruction(constant, expr->id());
+    return true;
+  }
+  return false;
+}
+
+
 HInstruction* HOptimizedGraphBuilder::BuildNamedAccess(
     PropertyAccessType access,
     BailoutId ast_id,
     BailoutId return_id,
     Expression* expr,
     HValue* object,
     Handle<String> name,
     HValue* value,
     bool is_uninitialized) {
   SmallMapList* types;
@@ skipping 80 matching lines @@
   }
   return ast_context()->ReturnInstruction(instr, ast_id);
 }
 
 
 void HOptimizedGraphBuilder::VisitProperty(Property* expr) {
   ASSERT(!HasStackOverflow());
   ASSERT(current_block() != NULL);
   ASSERT(current_block()->HasPredecessor());
 
-  if (TryArgumentsAccess(expr)) return;
+  if (TryArgumentsAccess(expr) || TryMathConstant(expr)) return;
 
   CHECK_ALIVE(VisitForValue(expr->obj()));
   if ((!expr->IsFunctionPrototype() && !expr->key()->IsPropertyName()) ||
       expr->IsStringAccess()) {
     CHECK_ALIVE(VisitForValue(expr->key()));
   }
 
   BuildLoad(expr, expr->id());
 }
 
@@ skipping 4557 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal