IR cleanup: pass deopt id as constructor argument instead of doing deopt_id_ assignment.

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
@@ skipping 20 matching lines @@
 DEFINE_FLAG(bool, two_args_smi_icd, true,
     "Generate special IC stubs for two args Smi operations");
 DEFINE_FLAG(bool, unbox_numeric_fields, true,
     "Support unboxed double and float32x4 fields.");
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, eliminate_type_checks);
 DECLARE_FLAG(bool, trace_optimization);
 DECLARE_FLAG(bool, trace_constant_propagation);
 DECLARE_FLAG(bool, throw_on_javascript_int_overflow);
 
-Definition::Definition()
-    : range_(NULL),
+Definition::Definition(intptr_t deopt_id)
+    : Instruction(deopt_id),
+      range_(NULL),
       type_(NULL),
       temp_index_(-1),
       ssa_temp_index_(-1),
       input_use_list_(NULL),
       env_use_list_(NULL),
       constant_value_(Object::ZoneHandle(ConstantPropagator::Unknown())) {
 }
 
 
 Definition* Definition::OriginalDefinition() {
@@ skipping 48 matching lines @@
 
 static int LowestFirst(const intptr_t* a, const intptr_t* b) {
   return *a - *b;
 }
 
 
 CheckClassInstr::CheckClassInstr(Value* value,
                                  intptr_t deopt_id,
                                  const ICData& unary_checks,
                                  intptr_t token_pos)
-    : unary_checks_(unary_checks),
+    : TemplateInstruction<1>(deopt_id),
+      unary_checks_(unary_checks),
       cids_(unary_checks.NumberOfChecks()),
       licm_hoisted_(false),
       token_pos_(token_pos) {
   ASSERT(unary_checks.IsZoneHandle());
   // Expected useful check data.
   ASSERT(!unary_checks_.IsNull());
   ASSERT(unary_checks_.NumberOfChecks() > 0);
   ASSERT(unary_checks_.NumArgsTested() == 1);
   SetInputAt(0, value);
-  deopt_id_ = deopt_id;
   // Otherwise use CheckSmiInstr.
   ASSERT((unary_checks_.NumberOfChecks() != 1) ||
          (unary_checks_.GetReceiverClassIdAt(0) != kSmiCid));
   for (intptr_t i = 0; i < unary_checks.NumberOfChecks(); ++i) {
     cids_.Add(unary_checks.GetReceiverClassIdAt(i));
   }
   cids_.Sort(LowestFirst);
 }
 
 
@@ skipping 1482 matching lines @@
       } else if (rhs == 0) {
         return right()->definition();
       } else if (rhs == 2) {
         ConstantInstr* constant_1 =
             flow_graph->GetConstant(Smi::Handle(Smi::New(1)));
         BinaryIntegerOpInstr* shift =
             BinaryIntegerOpInstr::Make(representation(),
                                        Token::kSHL,
                                        left()->CopyWithType(),
                                        new Value(constant_1),
-                                       deopt_id_,
+                                       GetDeoptId(),
                                        can_overflow(),
                                        is_truncating(),
                                        range());
         if (shift != NULL) {
           flow_graph->InsertBefore(this, shift, env(), FlowGraph::kValue);
           return shift;
         }
       }
 
       break;
@@ skipping 17 matching lines @@
       }
       break;
     case Token::kBIT_XOR:
       if (rhs == 0) {
         return left()->definition();
       } else if (rhs == range_mask) {
         UnaryIntegerOpInstr* bit_not =
             UnaryIntegerOpInstr::Make(representation(),
                                       Token::kBIT_NOT,
                                       left()->CopyWithType(),
-                                      deopt_id_,
+                                      GetDeoptId(),
                                       range());
         if (bit_not != NULL) {
           flow_graph->InsertBefore(this, bit_not, env(), FlowGraph::kValue);
           return bit_not;
         }
       }
       break;
 
     case Token::kSUB:
       if (rhs == 0) {
         return left()->definition();
       }
       break;
 
     case Token::kTRUNCDIV:
       if (rhs == 1) {
         return left()->definition();
       } else if (rhs == -1) {
         UnaryIntegerOpInstr* negation =
             UnaryIntegerOpInstr::Make(representation(),
                                       Token::kNEGATE,
                                       left()->CopyWithType(),
-                                      deopt_id_,
+                                      GetDeoptId(),
                                       range());
         if (negation != NULL) {
           flow_graph->InsertBefore(this, negation, env(), FlowGraph::kValue);
           return negation;
         }
       }
       break;
 
     case Token::kSHR:
       if (rhs == 0) {
         return left()->definition();
       } else if (rhs < 0) {
         DeoptimizeInstr* deopt =
-            new DeoptimizeInstr(ICData::kDeoptBinarySmiOp, deopt_id_);
+            new DeoptimizeInstr(ICData::kDeoptBinarySmiOp, GetDeoptId());
         flow_graph->InsertBefore(this, deopt, env(), FlowGraph::kEffect);
         return flow_graph->GetConstant(Smi::Handle(Smi::New(0)));
       }
       break;
 
     case Token::kSHL: {
       const intptr_t kMaxShift = RepresentationBits(representation()) - 1;
       if (rhs == 0) {
         return left()->definition();
       } else if ((rhs < 0) || (rhs >= kMaxShift)) {
         if ((rhs < 0) || !is_truncating()) {
           DeoptimizeInstr* deopt =
-              new DeoptimizeInstr(ICData::kDeoptBinarySmiOp, deopt_id_);
+              new DeoptimizeInstr(ICData::kDeoptBinarySmiOp, GetDeoptId());
           flow_graph->InsertBefore(this, deopt, env(), FlowGraph::kEffect);
         }
         return flow_graph->GetConstant(Smi::Handle(Smi::New(0)));
       }
       break;
     }
 
     default:
       break;
   }
@@ skipping 230 matching lines @@
   BoxIntNInstr* box_defn = value()->definition()->AsBoxIntN();
   if (box_defn != NULL) {
     if (box_defn->value()->definition()->representation() == representation()) {
       return box_defn->value()->definition();
     } else {
       UnboxedIntConverterInstr* converter = new UnboxedIntConverterInstr(
           box_defn->value()->definition()->representation(),
           representation(),
           box_defn->value()->CopyWithType(),
           (representation() == kUnboxedInt32) ?
-              deopt_id_ : Isolate::kNoDeoptId);
+              GetDeoptId() : Isolate::kNoDeoptId);
       if ((representation() == kUnboxedInt32) && is_truncating()) {
         converter->mark_truncating();
       }
       flow_graph->InsertBefore(this, converter, env(), FlowGraph::kValue);
       return converter;
     }
   }
 
   return this;
 }
 
 
 Definition* UnboxedIntConverterInstr::Canonicalize(FlowGraph* flow_graph) {
   if (!HasUses()) return NULL;
 
   UnboxedIntConverterInstr* box_defn =
       value()->definition()->AsUnboxedIntConverter();
   if ((box_defn != NULL) && (box_defn->representation() == from())) {
     if (box_defn->from() == to()) {
       return box_defn->value()->definition();
     }
 
     UnboxedIntConverterInstr* converter = new UnboxedIntConverterInstr(
         box_defn->from(),
         representation(),
         box_defn->value()->CopyWithType(),
-        (to() == kUnboxedInt32) ? deopt_id_ : Isolate::kNoDeoptId);
+        (to() == kUnboxedInt32) ? GetDeoptId() : Isolate::kNoDeoptId);
     if ((representation() == kUnboxedInt32) && is_truncating()) {
       converter->mark_truncating();
     }
     flow_graph->InsertBefore(this, converter, env(), FlowGraph::kValue);
     return converter;
   }
 
   UnboxIntegerInstr* unbox_defn = value()->definition()->AsUnboxInteger();
   if (unbox_defn != NULL &&
       (from() == kUnboxedMint) &&
       (to() == kUnboxedInt32) &&
       unbox_defn->HasOnlyInputUse(value())) {
     // TODO(vegorov): there is a duplication of code between UnboxedIntCoverter
     // and code path that unboxes Mint into Int32. We should just schedule
     // these instructions close to each other instead of fusing them.
     Definition* replacement =
-        new UnboxInt32Instr(unbox_defn->value()->CopyWithType(), deopt_id_);
+        new UnboxInt32Instr(unbox_defn->value()->CopyWithType(), GetDeoptId());
     if (is_truncating()) {
       replacement->AsUnboxInt32()->mark_truncating();
     }
     flow_graph->InsertBefore(this,
                              replacement,
                              env(),
                              FlowGraph::kValue);
     return replacement;
   }
 
@@ skipping 470 matching lines @@
                                                      bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void JoinEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ Bind(compiler->GetJumpLabel(this));
   if (!compiler->is_optimizing()) {
     compiler->AddCurrentDescriptor(RawPcDescriptors::kDeopt,
-                                   deopt_id_,
+                                   GetDeoptId(),
                                    Scanner::kNoSourcePos);
   }
   if (HasParallelMove()) {
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
 }
 
 
 LocationSummary* TargetEntryInstr::MakeLocationSummary(Isolate* isolate,
                                                        bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void TargetEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ Bind(compiler->GetJumpLabel(this));
   if (!compiler->is_optimizing()) {
     if (compiler->NeedsEdgeCounter(this)) {
       compiler->EmitEdgeCounter();
     }
     // The deoptimization descriptor points after the edge counter code for
     // uniformity with ARM and MIPS, where we can reuse pattern matching
     // code that matches backwards from the end of the pattern.
     compiler->AddCurrentDescriptor(RawPcDescriptors::kDeopt,
-                                   deopt_id_,
+                                   GetDeoptId(),
                                    Scanner::kNoSourcePos);
   }
   if (HasParallelMove()) {
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
 }
 
 
 LocationSummary* PhiInstr::MakeLocationSummary(Isolate* isolate,
                                                bool optimizing) const {
@@ skipping 185 matching lines @@
   ASSERT((InputCount() == 0) || (locs()->out(0).reg() == locs()->in(0).reg()));
   __ Drop(num_temps());
 }
 
 
 StrictCompareInstr::StrictCompareInstr(intptr_t token_pos,
                                        Token::Kind kind,
                                        Value* left,
                                        Value* right,
                                        bool needs_number_check)
-    : ComparisonInstr(token_pos, kind, left, right),
+    : ComparisonInstr(token_pos,
+                      kind,
+                      left,
+                      right,
+                      Isolate::Current()->GetNextDeoptId()),
       needs_number_check_(needs_number_check) {
-  deopt_id_ = Isolate::Current()->GetNextDeoptId();
   ASSERT((kind == Token::kEQ_STRICT) || (kind == Token::kNE_STRICT));
 }
 
 
 LocationSummary* InstanceCallInstr::MakeLocationSummary(Isolate* isolate,
                                                         bool optimizing) const {
   return MakeCallSummary();
 }
 
 
@@ skipping 466 matching lines @@
   }
   ASSERT(result.IsString());
   const String& concatenated =
       String::ZoneHandle(Symbols::New(String::Cast(result)));
   return flow_graph->GetConstant(concatenated);
 }
 
 
 InvokeMathCFunctionInstr::InvokeMathCFunctionInstr(
     ZoneGrowableArray<Value*>* inputs,
-    intptr_t original_deopt_id,
+    intptr_t deopt_id,
     MethodRecognizer::Kind recognized_kind,
     intptr_t token_pos)
-    : inputs_(inputs),
+    : Definition(deopt_id),
+      inputs_(inputs),
       recognized_kind_(recognized_kind),
       token_pos_(token_pos) {
   ASSERT(inputs_->length() == ArgumentCountFor(recognized_kind_));
   for (intptr_t i = 0; i < inputs_->length(); ++i) {
     ASSERT((*inputs)[i] != NULL);
     (*inputs)[i]->set_instruction(this);
     (*inputs)[i]->set_use_index(i);
   }
-  deopt_id_ = original_deopt_id;
 }
 
 
 intptr_t InvokeMathCFunctionInstr::ArgumentCountFor(
     MethodRecognizer::Kind kind) {
   switch (kind) {
     case MethodRecognizer::kDoubleTruncate:
     case MethodRecognizer::kDoubleFloor:
     case MethodRecognizer::kDoubleCeil: {
       ASSERT(!TargetCPUFeatures::double_truncate_round_supported());
@@ skipping 89 matching lines @@
     case kCos:           return "cos";
     case kSqrt:          return "sqrt";
     case kDoubleSquare:  return "double-square";
   }
   UNREACHABLE();
   return "";
 }
 
 
 MergedMathInstr::MergedMathInstr(ZoneGrowableArray<Value*>* inputs,
-                                 intptr_t original_deopt_id,
+                                 intptr_t deopt_id,
                                  MergedMathInstr::Kind kind)
-    : inputs_(inputs),
+    : Definition(deopt_id),
+      inputs_(inputs),
       kind_(kind) {
   ASSERT(inputs_->length() == InputCountFor(kind_));
   for (intptr_t i = 0; i < inputs_->length(); ++i) {
     ASSERT((*inputs)[i] != NULL);
     (*inputs)[i]->set_instruction(this);
     (*inputs)[i]->set_use_index(i);
   }
-  deopt_id_ = original_deopt_id;
 }
 
 
 intptr_t MergedMathInstr::OutputIndexOf(intptr_t kind) {
   switch (kind) {
     case MethodRecognizer::kMathSin: return 1;
     case MethodRecognizer::kMathCos: return 0;
     default: UNIMPLEMENTED(); return -1;
   }
 }
 
 
 intptr_t MergedMathInstr::OutputIndexOf(Token::Kind token) {
   switch (token) {
     case Token::kTRUNCDIV: return 0;
     case Token::kMOD: return 1;
     default: UNIMPLEMENTED(); return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart