NOT FOR COMMITTING: Add fast side-effect free floating point expressions.

src/ia32/codegen-ia32.cc

 // Copyright 2010 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 20 matching lines @@
 #include "codegen-inl.h"
 #include "compiler.h"
 #include "debug.h"
 #include "ic-inl.h"
 #include "jsregexp.h"
 #include "parser.h"
 #include "regexp-macro-assembler.h"
 #include "regexp-stack.h"
 #include "register-allocator-inl.h"
 #include "runtime.h"
+#include "safe-codegen-ia32.h"
 #include "scopes.h"
 #include "virtual-frame-inl.h"
 
 namespace v8 {
 namespace internal {
 
 #define __ ACCESS_MASM(masm_)
 
 // -------------------------------------------------------------------------
 // Platform-specific DeferredCode functions.
@@ skipping 531 matching lines @@
     Result result =
         LoadFromSlotCheckForArguments(variable->slot(), INSIDE_TYPEOF);
     frame()->Push(&result);
   } else {
     // Anything else can be handled normally.
     Load(expr);
   }
 }
 
 
+void CodeGenerator::LoadPossiblySafeExpression(Expression* expr) {
+  SafeSyntaxChecker checker;
+  if (checker.Check(expr)) {
+    __ IncrementCounter(&Counters::safe_expression_tried, 1);
+    JumpTarget unsafe;
+    JumpTarget done;
+    Result scratch = allocator_->Allocate();
+    ASSERT(scratch.is_register());
+    Result result = allocator_->Allocate();
+    ASSERT(result.is_register());
+    SafeGenerator safe_generator(masm_, &unsafe, this, &scratch, &result);
+    result = safe_generator.Generate(expr);
+    frame()->Push(&result);
+    __ IncrementCounter(&Counters::safe_expression_succeeded, 1);
+    done.Jump();
+
+    unsafe.Bind();
+    Load(expr);
+    done.Bind();
+  } else {
+    Load(expr);
+  }
+}
+
+
 ArgumentsAllocationMode CodeGenerator::ArgumentsMode() {
   if (scope()->arguments() == NULL) return NO_ARGUMENTS_ALLOCATION;
   ASSERT(scope()->arguments_shadow() != NULL);
   // We don't want to do lazy arguments allocation for functions that
   // have heap-allocated contexts, because it interfers with the
   // uninitialized const tracking in the context objects.
   return (scope()->num_heap_slots() > 0)
       ? EAGER_ARGUMENTS_ALLOCATION
       : LAZY_ARGUMENTS_ALLOCATION;
 }
@@ skipping 2313 matching lines @@
   CodeForStatementPosition(node);
   node->target()->break_target()->Jump();
 }
 
 
 void CodeGenerator::VisitReturnStatement(ReturnStatement* node) {
   ASSERT(!in_spilled_code());
   Comment cmnt(masm_, "[ ReturnStatement");
 
   CodeForStatementPosition(node);
-  Load(node->expression());
+  LoadPossiblySafeExpression(node->expression());
   Result return_value = frame_->Pop();
   masm()->WriteRecordedPositions();
   if (function_return_is_shadowed_) {
     function_return_.Jump(&return_value);
   } else {
     frame_->PrepareForReturn();
     if (function_return_.is_bound()) {
       // If the function return label is already bound we reuse the
       // code by jumping to the return site.
       function_return_.Jump(&return_value);
@@ skipping 1802 matching lines @@
   Comment cmnt(masm(), "[ Variable Assignment");
   Variable* var = node->target()->AsVariableProxy()->AsVariable();
   ASSERT(var != NULL);
   Slot* slot = var->slot();
   ASSERT(slot != NULL);
 
   // Evaluate the right-hand side.
   if (node->is_compound()) {
     Result result = LoadFromSlotCheckForArguments(slot, NOT_INSIDE_TYPEOF);
     frame()->Push(&result);
-    Load(node->value());
+    LoadPossiblySafeExpression(node->value());
 
     bool overwrite_value =
         (node->value()->AsBinaryOperation() != NULL &&
          node->value()->AsBinaryOperation()->ResultOverwriteAllowed());
     GenericBinaryOperation(node->binary_op(),
                            node->type(),
                            overwrite_value ? OVERWRITE_RIGHT : NO_OVERWRITE);
   } else {
-    Load(node->value());
+    LoadPossiblySafeExpression(node->value());
   }
 
   // Perform the assignment.
   if (var->mode() != Variable::CONST || node->op() == Token::INIT_CONST) {
     CodeForSourcePosition(node->position());
     StoreToSlot(slot,
                 node->op() == Token::INIT_CONST ? CONST_INIT : NOT_CONST_INIT);
   }
   ASSERT(frame()->height() == original_height + 1);
 }
@@ skipping 47 matching lines @@
     } else if (var != NULL) {
       // The LoadIC stub expects the object in eax.
       // Freeing eax causes the code generator to load the global into it.
       frame_->Spill(eax);
       LoadGlobal();
     } else {
       frame()->Dup();
     }
     Result value = EmitNamedLoad(name, var != NULL);
     frame()->Push(&value);
-    Load(node->value());
+    LoadPossiblySafeExpression(node->value());
 
     bool overwrite_value =
         (node->value()->AsBinaryOperation() != NULL &&
          node->value()->AsBinaryOperation()->ResultOverwriteAllowed());
     GenericBinaryOperation(node->binary_op(),
                            node->type(),
                            overwrite_value ? OVERWRITE_RIGHT : NO_OVERWRITE);
   } else {
-    Load(node->value());
+    LoadPossiblySafeExpression(node->value());
   }
 
   // Perform the assignment.  It is safe to ignore constants here.
   ASSERT(var == NULL || var->mode() != Variable::CONST);
   ASSERT_NE(Token::INIT_CONST, node->op());
   if (is_trivial_receiver) {
     Result value = frame()->Pop();
     frame()->Push(prop->obj());
     frame()->Push(&value);
   }
@@ skipping 49 matching lines @@
   // Evaluate the key subexpression.
   Load(prop->key());
 
   // Evaluate the right-hand side.
   if (node->is_compound()) {
     // Duplicate receiver and key.
     frame()->PushElementAt(1);
     frame()->PushElementAt(1);
     Result value = EmitKeyedLoad();
     frame()->Push(&value);
-    Load(node->value());
+    LoadPossiblySafeExpression(node->value());
 
     bool overwrite_value =
         (node->value()->AsBinaryOperation() != NULL &&
          node->value()->AsBinaryOperation()->ResultOverwriteAllowed());
     GenericBinaryOperation(node->binary_op(),
                            node->type(),
                            overwrite_value ? OVERWRITE_RIGHT : NO_OVERWRITE);
   } else {
-    Load(node->value());
+    LoadPossiblySafeExpression(node->value());
   }
 
   // Perform the assignment.  It is safe to ignore constants here.
   ASSERT(node->op() != Token::INIT_CONST);
   CodeForSourcePosition(node->position());
   Result answer = EmitKeyedStore(prop->key()->type());
   frame()->Push(&answer);
 
   if (node->ends_initialization_block()) {
     // The argument to the runtime call is the extra copy of the receiver,
@@ skipping 89 matching lines @@
     // call.  Then we call the resolved function using the given
     // arguments.
 
     // Prepare the stack for the call to the resolved function.
     Load(function);
 
     // Allocate a frame slot for the receiver.
     frame_->Push(Factory::undefined_value());
     int arg_count = args->length();
     for (int i = 0; i < arg_count; i++) {
-      Load(args->at(i));
+      LoadPossiblySafeExpression(args->at(i));
     }
 
     // Prepare the stack for the call to ResolvePossiblyDirectEval.
     frame_->PushElementAt(arg_count + 1);
     if (arg_count > 0) {
       frame_->PushElementAt(arg_count);
     } else {
       frame_->Push(Factory::undefined_value());
     }
 
@@ skipping 28 matching lines @@
     // ----------------------------------
 
     // Pass the global object as the receiver and let the IC stub
     // patch the stack to use the global proxy as 'this' in the
     // invoked function.
     LoadGlobal();
 
     // Load the arguments.
     int arg_count = args->length();
     for (int i = 0; i < arg_count; i++) {
-      Load(args->at(i));
+      LoadPossiblySafeExpression(args->at(i));
     }
 
     // Push the name of the function onto the frame.
     frame_->Push(var->name());
 
     // Call the IC initialization code.
     CodeForSourcePosition(node->position());
     Result result = frame_->CallCallIC(RelocInfo::CODE_TARGET_CONTEXT,
                                        arg_count,
                                        loop_nesting());
@@ skipping 50 matching lines @@
                       args->at(1)->AsVariableProxy(),
                       node->position());
 
       } else {
         // Push the receiver onto the frame.
         Load(property->obj());
 
         // Load the arguments.
         int arg_count = args->length();
         for (int i = 0; i < arg_count; i++) {
-          Load(args->at(i));
+          LoadPossiblySafeExpression(args->at(i));
         }
 
         // Push the name of the function onto the frame.
         frame_->Push(name);
 
         // Call the IC initialization code.
         CodeForSourcePosition(node->position());
         Result result =
             frame_->CallCallIC(RelocInfo::CODE_TARGET, arg_count,
                                loop_nesting());
@@ skipping 6126 matching lines @@
 
   // Call the runtime; it returns -1 (less), 0 (equal), or 1 (greater)
   // tagged as a small integer.
   __ bind(&runtime);
   __ TailCallRuntime(Runtime::kStringCompare, 2, 1);
 }
 
 #undef __
 
 } }  // namespace v8::internal