Some performance improvements to make raytracer faster (e.g, support intensified operation in mix...

runtime/vm/parser.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 4905 matching lines @@
               str_concat->AddExpr(lit);
             }
           } else if (left_operand->IsStringConcatNode()) {
             str_concat = left_operand->AsStringConcatNode();
           }
         }
         if (str_concat != NULL) {
           str_concat->AddExpr(right_operand);
           left_operand = str_concat;
         } else {
-          left_operand = new BinaryOpNode(
+          left_operand = OptimizeBinaryOpNode(
               op_pos, op_kind, left_operand, right_operand);
         }
       }
     }
     current_preced--;
   }
   return left_operand;
 }
 
 
@@ skipping 92 matching lines @@
       current_block_->statements->Add(save);
       AstNode* load = new LoadLocalNode(token_index, *temp);
       getter = new InstanceGetterNode(token_index, load, getter->field_name());
     }
     return getter;
   }
   return node;
 }
 
 
+// TODO(srdjan): Implement other optimizations.
+AstNode* Parser::OptimizeBinaryOpNode(intptr_t op_pos,
+                                      Token::Kind binary_op,
+                                      AstNode* lhs,
+                                      AstNode* rhs) {
+  LiteralNode* lhs_literal = lhs->AsLiteralNode();
+  LiteralNode* rhs_literal = rhs->AsLiteralNode();
+  if ((lhs_literal != NULL) && (rhs_literal != NULL)) {
+    if (lhs_literal->literal().IsDouble() &&
+        rhs_literal->literal().IsDouble()) {
+      Double& dbl_obj = Double::ZoneHandle();
+      dbl_obj ^= lhs_literal->literal().raw();
+      double left_double = dbl_obj.value();
+      dbl_obj ^= rhs_literal->literal().raw();
+      double right_double = dbl_obj.value();
+      if (binary_op == Token::kDIV) {
+        dbl_obj = Double::New(left_double / right_double);

[siva, 2011/10/21 00:41:52]

what if right_double is 0.0?
Also do you have to do something special if left_double is Nan or right_double
is Nan.

[srdjan, 2011/10/21 06:52:59]

The division in C++ behaves the same as in Dart (see Double_div in double.cc).
For definition of division by 0.0 see also interface double (Infinity or NaN).

+        return new LiteralNode(op_pos, dbl_obj);
+      }
+    }
+  }
+  return new BinaryOpNode(op_pos, binary_op, lhs, rhs);
+}
+
+
 AstNode* Parser::ExpandAssignableOp(intptr_t op_pos,
                                     Token::Kind assignment_op,
                                     AstNode* lhs,
                                     AstNode* rhs) {
   TRACE_PARSER("ExpandAssignableOp");
   switch (assignment_op) {
     case Token::kASSIGN:
       return rhs;
     case Token::kASSIGN_ADD:
       return new BinaryOpNode(op_pos, Token::kADD, lhs, rhs);
@@ skipping 1931 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart