Renaming Unboxed* IL instructions to shorter names.

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2012, 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/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 527 matching lines @@
 
     // Check that either left or right are not a smi.  Result or a
     // binary operation with two smis is a smi not a double.
     InsertBefore(call,
                  new CheckEitherNonSmiInstr(left->Copy(),
                                             right->Copy(),
                                             call),
                  call->env(),
                  Definition::kEffect);
 
-    UnboxedDoubleBinaryOpInstr* double_bin_op =
-        new UnboxedDoubleBinaryOpInstr(op_kind,
-                                       left->Copy(),
-                                       right->Copy(),
-                                       call);
+    BinaryDoubleOpInstr* double_bin_op =
+        new BinaryDoubleOpInstr(op_kind, left->Copy(), right->Copy(), call);
     call->ReplaceWith(double_bin_op, current_iterator());
     RemovePushArguments(call);
   } else if (operands_type == kMintCid) {
     Value* left = call->ArgumentAt(0)->value();
     Value* right = call->ArgumentAt(1)->value();
-    UnboxedMintBinaryOpInstr* bin_op =
-        new UnboxedMintBinaryOpInstr(op_kind, left, right, call);
+    BinaryMintOpInstr* bin_op =
+        new BinaryMintOpInstr(op_kind, left, right, call);
     call->ReplaceWith(bin_op, current_iterator());
     RemovePushArguments(call);
   } else if (op_kind == Token::kMOD) {
     // TODO(vegorov): implement fast path code for modulo.
     ASSERT(operands_type == kSmiCid);
     if (!call->ArgumentAt(1)->value()->BindsToConstant()) return false;
     const Object& obj = call->ArgumentAt(1)->value()->BoundConstant();
     if (!obj.IsSmi()) return false;
     const intptr_t value = Smi::Cast(obj).Value();
     if ((value > 0) && Utils::IsPowerOfTwo(value)) {
@@ skipping 43 matching lines @@
                  new CheckSmiInstr(value->Copy(), call->deopt_id()),
                  call->env(),
                  Definition::kEffect);
     unary_op = new UnarySmiOpInstr(op_kind,
                                    (op_kind == Token::kNEGATE) ? call : NULL,
                                    value);
   } else if ((op_kind == Token::kBIT_NOT) &&
              HasOnlySmiOrMint(*call->ic_data()) &&
              FlowGraphCompiler::SupportsUnboxedMints()) {
     Value* value = call->ArgumentAt(0)->value();
-    unary_op = new UnboxedMintUnaryOpInstr(op_kind, value, call);
+    unary_op = new UnaryMintOpInstr(op_kind, value, call);
   } else if (HasOnlyOneDouble(*call->ic_data()) &&
              (op_kind == Token::kNEGATE)) {
     Value* value = call->ArgumentAt(0)->value();
     AddCheckClass(call, value->Copy());
     ConstantInstr* minus_one =
         new ConstantInstr(Double::ZoneHandle(Double::NewCanonical(-1)));
     InsertBefore(call, minus_one, NULL, Definition::kValue);
-    unary_op = new UnboxedDoubleBinaryOpInstr(Token::kMUL,
-                                              value,
-                                              new Value(minus_one),
-                                              call);
+    unary_op = new BinaryDoubleOpInstr(Token::kMUL,
+                                       value,
+                                       new Value(minus_one),
+                                       call);
   }
   if (unary_op == NULL) return false;
 
   call->ReplaceWith(unary_op, current_iterator());
   RemovePushArguments(call);
   return true;
 }
 
 
 // Using field class
@@ skipping 2269 matching lines @@
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitUnboxInteger(UnboxIntegerInstr* instr) {
   // TODO(kmillikin): Handle unbox operation.
   SetValue(instr, non_constant_);
 }
 
 
-void ConstantPropagator::VisitUnboxedMintBinaryOp(
-    UnboxedMintBinaryOpInstr* instr) {
+void ConstantPropagator::VisitBinaryMintOp(
+    BinaryMintOpInstr* instr) {
   // TODO(kmillikin): Handle binary operations.
   SetValue(instr, non_constant_);
 }
 
 
-void ConstantPropagator::VisitUnboxedMintUnaryOp(
-    UnboxedMintUnaryOpInstr* instr) {
+void ConstantPropagator::VisitUnaryMintOp(
+    UnaryMintOpInstr* instr) {
   // TODO(kmillikin): Handle unary operations.
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitUnarySmiOp(UnarySmiOpInstr* instr) {
   const Object& value = instr->value()->definition()->constant_value();
   if (IsNonConstant(value)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(value)) {
@@ skipping 24 matching lines @@
   SetValue(instr, instr->value());
 }
 
 
 void ConstantPropagator::VisitConstraint(ConstraintInstr* instr) {
   // Should not be used outside of range analysis.
   UNREACHABLE();
 }
 
 
-void ConstantPropagator::VisitUnboxedDoubleBinaryOp(
-    UnboxedDoubleBinaryOpInstr* instr) {
+void ConstantPropagator::VisitBinaryDoubleOp(
+    BinaryDoubleOpInstr* instr) {
   const Object& left = instr->left()->definition()->constant_value();
   const Object& right = instr->right()->definition()->constant_value();
   if (IsNonConstant(left) || IsNonConstant(right)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(left) && IsConstant(right)) {
     // TODO(kmillikin): Handle binary operation.
     SetValue(instr, non_constant_);
   }
 }
 
@@ skipping 182 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart