Cleanups.

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, 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/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 212 matching lines @@
   }
   if (smi_shift_left == NULL) return;
 
   // Pattern recognized.
   smi_shift_left->set_is_truncating(true);
   ASSERT(bit_and_instr->IsBinarySmiOp() || bit_and_instr->IsBinaryMintOp());
   if (bit_and_instr->IsBinaryMintOp()) {
     // Replace Mint op with Smi op.
     BinarySmiOpInstr* smi_op = new BinarySmiOpInstr(
         Token::kBIT_AND,
-        bit_and_instr->AsBinaryMintOp()->instance_call(),
         new Value(left_instr),
-        new Value(right_instr));
+        new Value(right_instr),
+        bit_and_instr->deopt_id());
     bit_and_instr->ReplaceWith(smi_op, current_iterator());
   }
 }
 
 
 // Optimize (a << b) & c pattern: if c is a positive Smi or zero, then the
 // shift can be a truncating Smi shift-left and result is always Smi.
 void FlowGraphOptimizer::TryOptimizeLeftShiftWithBitAndPattern() {
   if (!FLAG_truncating_left_shift) return;
   ASSERT(current_iterator_ == NULL);
@@ skipping 481 matching lines @@
                          CheckArrayBoundInstr::LengthOffsetFor(class_id),
                          Type::ZoneHandle(Type::SmiType()),
                          is_immutable);
   length->set_result_cid(kSmiCid);
   length->set_recognized_kind(
       LoadFieldInstr::RecognizedKindFromArrayCid(class_id));
   InsertBefore(call, length, NULL, Definition::kValue);
   InsertBefore(call,
                new CheckArrayBoundInstr(new Value(length),
                                         new Value(*index),
-                                        call),
+                                        call->deopt_id()),
                call->env(),
                Definition::kEffect);
 
   if (class_id == kGrowableObjectArrayCid) {
     // Insert data elements load.
     LoadFieldInstr* elements =
         new LoadFieldInstr(new Value(*array),
                            GrowableObjectArray::data_offset(),
                            Type::ZoneHandle(Type::DynamicType()));
     elements->set_result_cid(kArrayCid);
@@ skipping 351 matching lines @@
 
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
   if (operands_type == kDoubleCid) {
     // Check that either left or right are not a smi.  Result of a
     // binary operation with two smis is a smi not a double.
     InsertBefore(call,
                  new CheckEitherNonSmiInstr(new Value(left),
                                             new Value(right),
-                                            call),
+                                            call->deopt_id()),
                  call->env(),
                  Definition::kEffect);
 
     BinaryDoubleOpInstr* double_bin_op =
         new BinaryDoubleOpInstr(op_kind, new Value(left), new Value(right),
-                                call);
+                                call->deopt_id());
     ReplaceCall(call, double_bin_op);
   } else if (operands_type == kMintCid) {
     if (!FlowGraphCompiler::SupportsUnboxedMints()) return false;
     if ((op_kind == Token::kSHR) || (op_kind == Token::kSHL)) {
       ShiftMintOpInstr* shift_op =
           new ShiftMintOpInstr(op_kind, new Value(left), new Value(right),
-                               call);
+                               call->deopt_id());
       ReplaceCall(call, shift_op);
     } else {
       BinaryMintOpInstr* bin_op =
           new BinaryMintOpInstr(op_kind, new Value(left), new Value(right),
-                                call);
+                                call->deopt_id());
       ReplaceCall(call, bin_op);
     }
   } else if (operands_type == kFloat32x4Cid) {
     // Type check left.
     AddCheckClass(left,
                   ICData::ZoneHandle(
                       call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                   call->deopt_id(),
                   call->env(),
                   call);
@@ skipping 40 matching lines @@
 
     // Insert smi check and attach a copy of the original environment
     // because the smi operation can still deoptimize.
     InsertBefore(call,
                  new CheckSmiInstr(new Value(left), call->deopt_id()),
                  call->env(),
                  Definition::kEffect);
     ConstantInstr* constant =
         flow_graph()->GetConstant(Smi::Handle(Smi::New(value - 1)));
     BinarySmiOpInstr* bin_op =
-        new BinarySmiOpInstr(Token::kBIT_AND, call,
+        new BinarySmiOpInstr(Token::kBIT_AND,
                              new Value(left),
-                             new Value(constant));
+                             new Value(constant),
+                             call->deopt_id());
     ReplaceCall(call, bin_op);
   } else {
     ASSERT(operands_type == kSmiCid);
     // Insert two smi checks and attach a copy of the original
     // environment because the smi operation can still deoptimize.
     AddCheckSmi(left, call->deopt_id(), call->env(), call);
     AddCheckSmi(right, call->deopt_id(), call->env(), call);
     if (left->IsConstant() &&
         ((op_kind == Token::kADD) || (op_kind == Token::kMUL))) {
       // Constant should be on the right side.
       Definition* temp = left;
       left = right;
       right = temp;
     }
     BinarySmiOpInstr* bin_op =
-        new BinarySmiOpInstr(op_kind, call, new Value(left), new Value(right));
+        new BinarySmiOpInstr(op_kind, new Value(left), new Value(right),
+                             call->deopt_id());
     ReplaceCall(call, bin_op);
   }
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithUnaryOp(InstanceCallInstr* call,
                                                Token::Kind op_kind) {
   ASSERT(call->ArgumentCount() == 1);
   Definition* input = call->ArgumentAt(0);
   Definition* unary_op = NULL;
   if (HasOnlyOneSmi(*call->ic_data())) {
     InsertBefore(call,
                  new CheckSmiInstr(new Value(input), call->deopt_id()),
                  call->env(),
                  Definition::kEffect);
-    unary_op = new UnarySmiOpInstr(op_kind, call, new Value(input));
+    unary_op = new UnarySmiOpInstr(op_kind, new Value(input), call->deopt_id());
   } else if ((op_kind == Token::kBIT_NOT) &&
              HasOnlySmiOrMint(*call->ic_data()) &&
              FlowGraphCompiler::SupportsUnboxedMints()) {
-    unary_op = new UnaryMintOpInstr(op_kind, new Value(input), call);
+    unary_op = new UnaryMintOpInstr(
+        op_kind, new Value(input), call->deopt_id());
   } else if (HasOnlyOneDouble(*call->ic_data()) &&
              (op_kind == Token::kNEGATE)) {
     AddReceiverCheck(call);
     ConstantInstr* minus_one =
         flow_graph()->GetConstant(Double::ZoneHandle(Double::NewCanonical(-1)));
     unary_op = new BinaryDoubleOpInstr(Token::kMUL,
                                        new Value(input),
                                        new Value(minus_one),
-                                       call);
+                                       call->deopt_id());
   }
   if (unary_op == NULL) return false;
 
   ReplaceCall(call, unary_op);
   return true;
 }
 
 
 // Using field class
 static RawField* GetField(intptr_t class_id, const String& field_name) {
@@ skipping 361 matching lines @@
     skip_check = constant_index.IsSmi() &&
         (Smi::Cast(constant_index).Value() < constant_string.Length());
   }
   if (!skip_check) {
     // Insert bounds check.
     LoadFieldInstr* length = BuildLoadStringLength(str);
     InsertBefore(call, length, NULL, Definition::kValue);
     InsertBefore(call,
                  new CheckArrayBoundInstr(new Value(length),
                                           new Value(index),
-                                          call),
+                                          call->deopt_id()),
                  call->env(),
                  Definition::kEffect);
   }
   return new LoadIndexedInstr(new Value(str),
                               new Value(index),
                               FlowGraphCompiler::ElementSizeFor(cid),
                               cid,
                               Isolate::kNoDeoptId);  // Can't deoptimize.
 }
 
@@ skipping 134 matching lines @@
         AddReceiverCheck(call);
         ASSERT(call->HasICData());
         const ICData& ic_data = *call->ic_data();
         Definition* input = call->ArgumentAt(0);
         Definition* d2i_instr = NULL;
         if (ic_data.deopt_reason() == kDeoptDoubleToSmi) {
           // Do not repeatedly deoptimize because result didn't fit into Smi.
           d2i_instr = new DoubleToIntegerInstr(new Value(input), call);
         } else {
           // Optimistically assume result fits into Smi.
-          d2i_instr = new DoubleToSmiInstr(new Value(input), call);
+          d2i_instr = new DoubleToSmiInstr(new Value(input), call->deopt_id());
         }
         ReplaceCall(call, d2i_instr);
         return true;
       }
       case MethodRecognizer::kDoubleMod:
       case MethodRecognizer::kDoublePow:
       case MethodRecognizer::kDoubleRound:
         ReplaceWithMathCFunction(call, recognized_kind);
         return true;
       case MethodRecognizer::kDoubleTruncate:
       case MethodRecognizer::kDoubleFloor:
       case MethodRecognizer::kDoubleCeil:
         if (!CPUFeatures::double_truncate_round_supported()) {
           ReplaceWithMathCFunction(call, recognized_kind);
         } else {
           AddReceiverCheck(call);
           DoubleToDoubleInstr* d2d_instr =
               new DoubleToDoubleInstr(new Value(call->ArgumentAt(0)),
-                                      call,
-                                      recognized_kind);
+                                      recognized_kind, call->deopt_id());
           ReplaceCall(call, d2d_instr);
         }
         return true;
       default:
         // Unsupported method.
         return false;
     }
   }
 
   if (IsSupportedByteArrayViewCid(class_ids[0]) &&
@@ skipping 428 matching lines @@
   length->set_recognized_kind(
       LoadFieldInstr::RecognizedKindFromArrayCid(receiver_cid));
   InsertBefore(call, length, NULL, Definition::kValue);
 
   // len_in_bytes = length * kBytesPerElement(receiver)
   intptr_t element_size = FlowGraphCompiler::ElementSizeFor(receiver_cid);
   ConstantInstr* bytes_per_element =
       flow_graph()->GetConstant(Smi::Handle(Smi::New(element_size)));
   BinarySmiOpInstr* len_in_bytes =
       new BinarySmiOpInstr(Token::kMUL,
-                           call,
                            new Value(length),
-                           new Value(bytes_per_element));
+                           new Value(bytes_per_element),
+                           call->deopt_id());
   InsertBefore(call, len_in_bytes, call->env(), Definition::kValue);
 
     // Check byte_index < len_in_bytes.
   InsertBefore(call,
                new CheckArrayBoundInstr(new Value(len_in_bytes),
                                         new Value(byte_index),
-                                        call),
+                                        call->deopt_id()),
                call->env(),
                Definition::kEffect);
 
   // Insert load of elements for external typed arrays.
   if (RawObject::IsExternalTypedDataClassId(receiver_cid)) {
     LoadUntaggedInstr* elements =
         new LoadUntaggedInstr(new Value(*array),
                               ExternalTypedData::data_offset());
     InsertBefore(call, elements, NULL, Definition::kValue);
     *array = elements;
@@ skipping 4922 matching lines @@
 
   // Insert materializations at environment uses.
   const Class& cls = Class::Handle(alloc->constructor().Owner());
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, cls, *fields);
   }
 }
 
 
 }  // namespace dart