Add flag —source-lines which emits appropriate source lines as code comments. Added token_pos to …

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/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 26 matching lines @@
     "Print constant propagation and useless code elimination.");
 DEFINE_FLAG(bool, trace_load_optimization, false,
     "Print live sets for load optimization pass.");
 DEFINE_FLAG(bool, trace_optimization, false, "Print optimization details.");
 DEFINE_FLAG(bool, trace_range_analysis, false, "Trace range analysis progress");
 DEFINE_FLAG(bool, truncating_left_shift, true,
     "Optimize left shift to truncate if possible");
 DEFINE_FLAG(bool, use_cha, true, "Use class hierarchy analysis.");
 DECLARE_FLAG(bool, eliminate_type_checks);
 DECLARE_FLAG(bool, enable_type_checks);
+DECLARE_FLAG(bool, source_lines);
 DECLARE_FLAG(bool, trace_type_check_elimination);
 
-
 static bool ShouldInlineSimd() {
   return FlowGraphCompiler::SupportsUnboxedSimd128();
 }
 
 
 // Optimize instance calls using ICData.
 void FlowGraphOptimizer::ApplyICData() {
   VisitBlocks();
 }
 
@@ skipping 210 matching lines @@
 
   // 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,
         new Value(left_instr),
         new Value(right_instr),
-        Isolate::kNoDeoptId);  // BIT_AND cannot deoptimize.
+        Isolate::kNoDeoptId,  // BIT_AND cannot deoptimize.
+        kNoTokenPos);
     bit_and_instr->ReplaceWith(smi_op, current_iterator());
   }
 }
 
 
 
 // Used by TryMergeDivMod.
 // Inserts a load-indexed instruction between a TRUNCDIV or MOD instruction,
 // and the using instruction. This is an intermediate step before merging.
 void FlowGraphOptimizer::AppendLoadIndexedForMerged(Definition* instr,
                                                     intptr_t ix,
                                                     intptr_t cid) {
   const intptr_t index_scale = FlowGraphCompiler::ElementSizeFor(cid);
   ConstantInstr* index_instr =
       flow_graph()->GetConstant(Smi::Handle(Smi::New(ix)));
   LoadIndexedInstr* load = new LoadIndexedInstr(new Value(instr),
                                                 new Value(index_instr),
                                                 index_scale,
                                                 cid,
-                                                Isolate::kNoDeoptId);
+                                                Isolate::kNoDeoptId,
+                                                instr->token_pos());
   instr->ReplaceUsesWith(load);
   flow_graph()->InsertAfter(instr, load, NULL, Definition::kValue);
 }
 
 
 void FlowGraphOptimizer::AppendExtractNthOutputForMerged(Definition* instr,
                                                          intptr_t index,
                                                          Representation rep,
                                                          intptr_t cid) {
   ExtractNthOutputInstr* extract = new ExtractNthOutputInstr(new Value(instr),
@@ skipping 629 matching lines @@
   call->ReplaceWith(replacement, current_iterator());
 }
 
 
 void FlowGraphOptimizer::AddCheckSmi(Definition* to_check,
                                      intptr_t deopt_id,
                                      Environment* deopt_environment,
                                      Instruction* insert_before) {
   if (to_check->Type()->ToCid() != kSmiCid) {
     InsertBefore(insert_before,
-                 new CheckSmiInstr(new Value(to_check), deopt_id),
+                 new CheckSmiInstr(new Value(to_check),
+                                   deopt_id,
+                                   insert_before->token_pos()),
                  deopt_environment,
                  Definition::kEffect);
   }
 }
 
 
 Instruction* FlowGraphOptimizer::GetCheckClass(Definition* to_check,
                                                const ICData& unary_checks,
-                                               intptr_t deopt_id) {
+                                               intptr_t deopt_id,
+                                               intptr_t token_pos) {
   if ((unary_checks.NumberOfChecks() == 1) &&
       (unary_checks.GetReceiverClassIdAt(0) == kSmiCid)) {
-    return new CheckSmiInstr(new Value(to_check), deopt_id);
+    return new CheckSmiInstr(new Value(to_check),
+                             deopt_id,
+                             token_pos);
   }
-  return new CheckClassInstr(new Value(to_check), deopt_id, unary_checks);
+  return new CheckClassInstr(
+      new Value(to_check), deopt_id, unary_checks, token_pos);
 }
 
 
 void FlowGraphOptimizer::AddCheckClass(Definition* to_check,
                                        const ICData& unary_checks,
                                        intptr_t deopt_id,
                                        Environment* deopt_environment,
                                        Instruction* insert_before) {
   // Type propagation has not run yet, we cannot eliminate the check.
-  Instruction* check = GetCheckClass(to_check, unary_checks, deopt_id);
+  Instruction* check = GetCheckClass(
+      to_check, unary_checks, deopt_id, insert_before->token_pos());
   InsertBefore(insert_before, check, deopt_environment, Definition::kEffect);
 }
 
 
 void FlowGraphOptimizer::AddReceiverCheck(InstanceCallInstr* call) {
   AddCheckClass(call->ArgumentAt(0),
                 ICData::ZoneHandle(call->ic_data()->AsUnaryClassChecks()),
                 call->deopt_id(),
                 call->env(),
                 call);
@@ skipping 170 matching lines @@
     Definition* type_args = NULL;
     switch (array_cid) {
       case kArrayCid:
       case kGrowableObjectArrayCid: {
         const Class& instantiator_class = Class::Handle(target.Owner());
         intptr_t type_arguments_field_offset =
             instantiator_class.type_arguments_field_offset();
         LoadFieldInstr* load_type_args =
             new LoadFieldInstr(new Value(array),
                                type_arguments_field_offset,
-                               Type::ZoneHandle());  // No type.
+                               Type::ZoneHandle(),
+                               call->token_pos());  // No type.
         cursor = flow_graph()->AppendTo(cursor,
                                         load_type_args,
                                         NULL,
                                         Definition::kValue);
 
         instantiator = array;
         type_args = load_type_args;
         break;
       }
       case kTypedDataInt8ArrayCid:
@@ skipping 60 matching lines @@
   // Check if store barrier is needed. Byte arrays don't need a store barrier.
   StoreBarrierType needs_store_barrier =
       (RawObject::IsTypedDataClassId(array_cid) ||
        RawObject::IsTypedDataViewClassId(array_cid) ||
        RawObject::IsExternalTypedDataClassId(array_cid)) ? kNoStoreBarrier
                                                          : kEmitStoreBarrier;
   if (!value_check.IsNull()) {
     // No store barrier needed because checked value is a smi, an unboxed mint,
     // an unboxed double, an unboxed Float32x4, or unboxed Int32x4.
     needs_store_barrier = kNoStoreBarrier;
-    Instruction* check =
-        GetCheckClass(stored_value, value_check, call->deopt_id());
+    Instruction* check = GetCheckClass(
+        stored_value, value_check, call->deopt_id(), call->token_pos());
     cursor = flow_graph()->AppendTo(cursor,
                                     check,
                                     call->env(),
                                     Definition::kEffect);
   }
 
   if (array_cid == kTypedDataFloat32ArrayCid) {
     stored_value =
         new DoubleToFloatInstr(new Value(stored_value), call->deopt_id());
     cursor = flow_graph()->AppendTo(cursor,
                                     stored_value,
                                     NULL,
                                     Definition::kValue);
   }
 
   intptr_t index_scale = FlowGraphCompiler::ElementSizeFor(array_cid);
   *last = new StoreIndexedInstr(new Value(array),
                                 new Value(index),
                                 new Value(stored_value),
                                 needs_store_barrier,
                                 index_scale,
                                 array_cid,
-                                call->deopt_id());
+                                call->deopt_id(),
+                                call->token_pos());
   flow_graph()->AppendTo(cursor,
                          *last,
                          call->env(),
                          Definition::kEffect);
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryInlineRecognizedMethod(intptr_t receiver_cid,
                                                    const Function& target,
@@ skipping 215 matching lines @@
 
 
 intptr_t FlowGraphOptimizer::PrepareInlineIndexedOp(Instruction* call,
                                                     intptr_t array_cid,
                                                     Definition** array,
                                                     Definition* index,
                                                     Instruction** cursor) {
   // Insert index smi check.
   *cursor = flow_graph()->AppendTo(*cursor,
                                    new CheckSmiInstr(new Value(index),
-                                                     call->deopt_id()),
+                                                     call->deopt_id(),
+                                                     call->token_pos()),
                                    call->env(),
                                    Definition::kEffect);
 
   // Insert array length load and bounds check.
   const bool is_immutable =
       CheckArrayBoundInstr::IsFixedLengthArrayType(array_cid);
   LoadFieldInstr* length =
       new LoadFieldInstr(new Value(*array),
                          CheckArrayBoundInstr::LengthOffsetFor(array_cid),
                          Type::ZoneHandle(Type::SmiType()),
+                         call->token_pos(),
                          is_immutable);
   length->set_result_cid(kSmiCid);
   length->set_recognized_kind(
       LoadFieldInstr::RecognizedKindFromArrayCid(array_cid));
   *cursor = flow_graph()->AppendTo(*cursor,
                                    length,
                                    NULL,
                                    Definition::kValue);
 
   *cursor = flow_graph()->AppendTo(*cursor,
                                    new CheckArrayBoundInstr(
                                        new Value(length),
                                        new Value(index),
                                        call->deopt_id()),
                                    call->env(),
                                    Definition::kEffect);
 
   if (array_cid == kGrowableObjectArrayCid) {
     // Insert data elements load.
     LoadFieldInstr* elements =
         new LoadFieldInstr(new Value(*array),
                            GrowableObjectArray::data_offset(),
-                           Type::ZoneHandle(Type::DynamicType()));
+                           Type::ZoneHandle(Type::DynamicType()),
+                           call->token_pos());
     elements->set_result_cid(kArrayCid);
     *cursor = flow_graph()->AppendTo(*cursor,
                                      elements,
                                      NULL,
                                      Definition::kValue);
     // Load from the data from backing store which is a fixed-length array.
     *array = elements;
     array_cid = kArrayCid;
   } else if (RawObject::IsExternalTypedDataClassId(array_cid)) {
     LoadUntaggedInstr* elements =
@@ skipping 38 matching lines @@
     deopt_id = ic_data.HasDeoptReasons() ?
         Isolate::kNoDeoptId : call->deopt_id();
   }
 
   // Array load and return.
   intptr_t index_scale = FlowGraphCompiler::ElementSizeFor(array_cid);
   *last = new LoadIndexedInstr(new Value(array),
                                new Value(index),
                                index_scale,
                                array_cid,
-                               deopt_id);
+                               deopt_id,
+                               call->token_pos());
   cursor = flow_graph()->AppendTo(
       cursor,
       *last,
       deopt_id != Isolate::kNoDeoptId ? call->env() : NULL,
       Definition::kValue);
 
   if (array_cid == kTypedDataFloat32ArrayCid) {
     *last = new FloatToDoubleInstr(new Value(*last), deopt_id);
     flow_graph()->AppendTo(cursor,
                            *last,
@@ skipping 166 matching lines @@
 
   intptr_t cid = kIllegalCid;
   if (HasOnlyTwoOf(ic_data, kOneByteStringCid)) {
     if (TryStringLengthOneEquality(call, op_kind)) {
       return true;
     } else {
       return false;
     }
   } else if (HasOnlyTwoOf(ic_data, kSmiCid)) {
     InsertBefore(call,
-                 new CheckSmiInstr(new Value(left), call->deopt_id()),
+                 new CheckSmiInstr(new Value(left),
+                                   call->deopt_id(),
+                                   call->token_pos()),
                  call->env(),
                  Definition::kEffect);
     InsertBefore(call,
-                 new CheckSmiInstr(new Value(right), call->deopt_id()),
+                 new CheckSmiInstr(new Value(right),
+                                   call->deopt_id(),
+                                   call->token_pos()),
                  call->env(),
                  Definition::kEffect);
     cid = kSmiCid;
   } else if (HasTwoMintOrSmi(ic_data) &&
              FlowGraphCompiler::SupportsUnboxedMints()) {
     cid = kMintCid;
   } else if (HasTwoDoubleOrSmi(ic_data)) {
     // Use double comparison.
     if (SmiFitsInDouble()) {
       cid = kDoubleCid;
@@ skipping 73 matching lines @@
   const ICData& ic_data = *call->ic_data();
   ASSERT(ic_data.NumArgsTested() == 2);
 
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
 
   intptr_t cid = kIllegalCid;
   if (HasOnlyTwoOf(ic_data, kSmiCid)) {
     InsertBefore(call,
-                 new CheckSmiInstr(new Value(left), call->deopt_id()),
+                 new CheckSmiInstr(new Value(left),
+                                   call->deopt_id(),
+                                   call->token_pos()),
                  call->env(),
                  Definition::kEffect);
     InsertBefore(call,
-                 new CheckSmiInstr(new Value(right), call->deopt_id()),
+                 new CheckSmiInstr(new Value(right),
+                                   call->deopt_id(),
+                                   call->token_pos()),
                  call->env(),
                  Definition::kEffect);
     cid = kSmiCid;
   } else if (HasTwoMintOrSmi(ic_data) &&
              FlowGraphCompiler::SupportsUnboxedMints()) {
     cid = kMintCid;
   } else if (HasTwoDoubleOrSmi(ic_data)) {
     // Use double comparison.
     if (SmiFitsInDouble()) {
       cid = kDoubleCid;
@@ skipping 153 matching lines @@
       InsertBefore(call,
                    new CheckEitherNonSmiInstr(new Value(left),
                                               new Value(right),
                                               call->deopt_id()),
                    call->env(),
                    Definition::kEffect);
     }
 
     BinaryDoubleOpInstr* double_bin_op =
         new BinaryDoubleOpInstr(op_kind, new Value(left), new Value(right),
-                                call->deopt_id());
+                                call->deopt_id(), call->token_pos());
     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->deopt_id());
       ReplaceCall(call, shift_op);
     } else {
       BinaryMintOpInstr* bin_op =
           new BinaryMintOpInstr(op_kind, new Value(left), new Value(right),
                                 call->deopt_id());
       ReplaceCall(call, bin_op);
     }
   } else if (operands_type == kFloat32x4Cid) {
     return InlineFloat32x4BinaryOp(call, op_kind);
   } else if (operands_type == kInt32x4Cid) {
     return InlineInt32x4BinaryOp(call, op_kind);
   } else if (operands_type == kFloat64x2Cid) {
     return InlineFloat64x2BinaryOp(call, op_kind);
   } else if (op_kind == Token::kMOD) {
     ASSERT(operands_type == kSmiCid);
     if (right->IsConstant()) {
       const Object& obj = right->AsConstant()->value();
       if (obj.IsSmi() && Utils::IsPowerOfTwo(Smi::Cast(obj).Value())) {
         // 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()),
+                     new CheckSmiInstr(new Value(left),
+                                       call->deopt_id(),
+                                       call->token_pos()),
                      call->env(),
                      Definition::kEffect);
         ConstantInstr* constant =
             flow_graph()->GetConstant(Smi::Handle(
                 Smi::New(Smi::Cast(obj).Value() - 1)));
         BinarySmiOpInstr* bin_op =
             new BinarySmiOpInstr(Token::kBIT_AND,
                                  new Value(left),
                                  new Value(constant),
-                                 call->deopt_id());
+                                 call->deopt_id(),
+                                 call->token_pos());
         ReplaceCall(call, bin_op);
         return true;
       }
     }
     // 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);
     BinarySmiOpInstr* bin_op =
         new BinarySmiOpInstr(op_kind, new Value(left), new Value(right),
-                             call->deopt_id());
+                             call->deopt_id(), call->token_pos());
     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, new Value(left), new Value(right),
-                             call->deopt_id());
+                             call->deopt_id(), call->token_pos());
     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()),
+                 new CheckSmiInstr(new Value(input),
+                                   call->deopt_id(),
+                                   call->token_pos()),
                  call->env(),
                  Definition::kEffect);
     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->deopt_id());
   } else if (HasOnlyOneDouble(*call->ic_data()) &&
              (op_kind == Token::kNEGATE)) {
@@ skipping 74 matching lines @@
   const Field& field = Field::ZoneHandle(GetField(class_ids[0], field_name));
   ASSERT(!field.IsNull());
 
   if (InstanceCallNeedsClassCheck(call)) {
     AddReceiverCheck(call);
   }
   LoadFieldInstr* load = new LoadFieldInstr(
       new Value(call->ArgumentAt(0)),
       &field,
       AbstractType::ZoneHandle(field.type()),
+      call->token_pos(),
       field.is_final());
   if (field.guarded_cid() != kIllegalCid) {
     if (!field.is_nullable() || (field.guarded_cid() == kNullCid)) {
       load->set_result_cid(field.guarded_cid());
     }
     FlowGraph::AddToGuardedFields(flow_graph_->guarded_fields(), &field);
   }
 
   // Discard the environment from the original instruction because the load
   // can't deoptimize.
@@ skipping 13 matching lines @@
 
 static LoadFieldInstr* BuildLoadStringLength(Definition* str) {
   // Treat length loads as mutable (i.e. affected by side effects) to avoid
   // hoisting them since we can't hoist the preceding class-check. This
   // is because of externalization of strings that affects their class-id.
   const bool is_immutable = false;
   LoadFieldInstr* load = new LoadFieldInstr(
       new Value(str),
       String::length_offset(),
       Type::ZoneHandle(Type::SmiType()),
+      str->token_pos(),
       is_immutable);
   load->set_result_cid(kSmiCid);
   load->set_recognized_kind(MethodRecognizer::kStringBaseLength);
   return load;
 }
 
 
 bool FlowGraphOptimizer::InlineFloat32x4Getter(InstanceCallInstr* call,
                                                MethodRecognizer::Kind getter) {
   if (!ShouldInlineSimd()) {
@@ skipping 334 matching lines @@
 // Returns the LoadIndexedInstr.
 Definition* FlowGraphOptimizer::PrepareInlineStringIndexOp(
     Instruction* call,
     intptr_t cid,
     Definition* str,
     Definition* index,
     Instruction* cursor) {
 
   cursor = flow_graph()->AppendTo(cursor,
                                   new CheckSmiInstr(new Value(index),
-                                                    call->deopt_id()),
+                                                    call->deopt_id(),
+                                                    call->token_pos()),
                                   call->env(),
                                   Definition::kEffect);
 
   // Load the length of the string.
   LoadFieldInstr* length = BuildLoadStringLength(str);
   cursor = flow_graph()->AppendTo(cursor, length, NULL, Definition::kValue);
   // Bounds check.
   cursor = flow_graph()->AppendTo(cursor,
                                    new CheckArrayBoundInstr(new Value(length),
                                                             new Value(index),
                                                             call->deopt_id()),
                                    call->env(),
                                    Definition::kEffect);
 
   LoadIndexedInstr* load_indexed = new LoadIndexedInstr(
       new Value(str),
       new Value(index),
       FlowGraphCompiler::ElementSizeFor(cid),
       cid,
-      Isolate::kNoDeoptId);
+      Isolate::kNoDeoptId,
+      call->token_pos());
 
   cursor = flow_graph()->AppendTo(cursor,
                                   load_indexed,
                                   NULL,
                                   Definition::kValue);
   ASSERT(cursor == load_indexed);
   return load_indexed;
 }
 
 
@@ skipping 51 matching lines @@
 void FlowGraphOptimizer::ReplaceWithMathCFunction(
     InstanceCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
   AddReceiverCheck(call);
   ZoneGrowableArray<Value*>* args =
       new ZoneGrowableArray<Value*>(call->ArgumentCount());
   for (intptr_t i = 0; i < call->ArgumentCount(); i++) {
     args->Add(new Value(call->ArgumentAt(i)));
   }
   InvokeMathCFunctionInstr* invoke =
-      new InvokeMathCFunctionInstr(args, call->deopt_id(), recognized_kind);
+      new InvokeMathCFunctionInstr(args,
+                                   call->deopt_id(),
+                                   recognized_kind,
+                                   call->token_pos());
   ReplaceCall(call, invoke);
 }
 
 
 static bool IsSupportedByteArrayViewCid(intptr_t cid) {
   switch (cid) {
     case kTypedDataInt8ArrayCid:
     case kTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid:
@@ skipping 31 matching lines @@
   if ((recognized_kind == MethodRecognizer::kGrowableArraySetData) &&
       (ic_data.NumberOfChecks() == 1) &&
       (class_ids[0] == kGrowableObjectArrayCid)) {
     // This is an internal method, no need to check argument types.
     Definition* array = call->ArgumentAt(0);
     Definition* value = call->ArgumentAt(1);
     StoreInstanceFieldInstr* store = new StoreInstanceFieldInstr(
         GrowableObjectArray::data_offset(),
         new Value(array),
         new Value(value),
-        kEmitStoreBarrier);
+        kEmitStoreBarrier,
+        call->token_pos());
     ReplaceCall(call, store);
     return true;
   }
 
   if ((recognized_kind == MethodRecognizer::kGrowableArraySetLength) &&
       (ic_data.NumberOfChecks() == 1) &&
       (class_ids[0] == kGrowableObjectArrayCid)) {
     // This is an internal method, no need to check argument types nor
     // range.
     Definition* array = call->ArgumentAt(0);
     Definition* value = call->ArgumentAt(1);
     StoreInstanceFieldInstr* store = new StoreInstanceFieldInstr(
         GrowableObjectArray::length_offset(),
         new Value(array),
         new Value(value),
-        kEmitStoreBarrier);
+        kEmitStoreBarrier,
+        call->token_pos());
     ReplaceCall(call, store);
     return true;
   }
 
   if (((recognized_kind == MethodRecognizer::kStringBaseCodeUnitAt) ||
        (recognized_kind == MethodRecognizer::kStringBaseCharAt)) &&
       (ic_data.NumberOfChecks() == 1) &&
       ((class_ids[0] == kOneByteStringCid) ||
        (class_ids[0] == kTwoByteStringCid))) {
     return TryReplaceInstanceCallWithInline(call);
   }
 
   if ((class_ids[0] == kOneByteStringCid) && (ic_data.NumberOfChecks() == 1)) {
     if (recognized_kind == MethodRecognizer::kOneByteStringSetAt) {
       // This is an internal method, no need to check argument types nor
       // range.
       Definition* str = call->ArgumentAt(0);
       Definition* index = call->ArgumentAt(1);
       Definition* value = call->ArgumentAt(2);
       StoreIndexedInstr* store_op = new StoreIndexedInstr(
           new Value(str),
           new Value(index),
           new Value(value),
           kNoStoreBarrier,
           1,  // Index scale
           kOneByteStringCid,
-          call->deopt_id());
+          call->deopt_id(),
+          call->token_pos());
       ReplaceCall(call, store_op);
       return true;
     }
     return false;
   }
 
   if ((recognized_kind == MethodRecognizer::kIntegerToDouble) &&
       (ic_data.NumberOfChecks() == 1) &&
       (class_ids[0] == kSmiCid)) {
     AddReceiverCheck(call);
-    ReplaceCall(call, new SmiToDoubleInstr(new Value(call->ArgumentAt(0))));
+    ReplaceCall(call,
+                new SmiToDoubleInstr(new Value(call->ArgumentAt(0)),
+                                     call->token_pos()));
     return true;
   }
 
   if (class_ids[0] == kDoubleCid) {
     switch (recognized_kind) {
       case MethodRecognizer::kDoubleToInteger: {
         AddReceiverCheck(call);
         ASSERT(call->HasICData());
         const ICData& ic_data = *call->ic_data();
         Definition* input = call->ArgumentAt(0);
@@ skipping 122 matching lines @@
           int32_mask->AsConstant()->value());
       const int64_t mask_value = mask_literal.AsInt64Value();
       ASSERT(mask_value >= 0);
       if (mask_value > Smi::kMaxValue) {
         // The result will not be Smi.
         return false;
       }
       BinarySmiOpInstr* left_shift =
           new BinarySmiOpInstr(Token::kSHL,
                                new Value(value), new Value(count),
-                               call->deopt_id());
+                               call->deopt_id(), call->token_pos());
       left_shift->set_is_truncating(true);
       if ((kBitsPerWord == 32) && (mask_value == 0xffffffffLL)) {
         // No BIT_AND operation needed.
         ReplaceCall(call, left_shift);
       } else {
         InsertBefore(call, left_shift, call->env(), Definition::kValue);
         BinarySmiOpInstr* bit_and =
             new BinarySmiOpInstr(Token::kBIT_AND,
                                  new Value(left_shift), new Value(int32_mask),
-                                 call->deopt_id());
+                                 call->deopt_id(), call->token_pos());
         ReplaceCall(call, bit_and);
       }
       return true;
     }
 
     if (HasTwoMintOrSmi(ic_data) &&
         HasOnlyOneSmi(ICData::Handle(ic_data.AsUnaryClassChecksForArgNr(1)))) {
       if (!FlowGraphCompiler::SupportsUnboxedMints() ||
           ic_data.HasDeoptReason(ICData::kDeoptShiftMintOp)) {
         return false;
@@ skipping 422 matching lines @@
     // Set deopt_id if we can optimistically assume that the result is Smi.
     // Assume mixed Mint/Smi if this instruction caused deoptimization once.
     deopt_id = ic_data.HasDeoptReasons() ?
         Isolate::kNoDeoptId : call->deopt_id();
   }
 
   *last = new LoadIndexedInstr(new Value(array),
                                new Value(index),
                                1,
                                view_cid,
-                               deopt_id);
+                               deopt_id,
+                               call->token_pos());
   cursor = flow_graph()->AppendTo(
       cursor,
       *last,
       deopt_id != Isolate::kNoDeoptId ? call->env() : NULL,
       Definition::kValue);
 
   if (view_cid == kTypedDataFloat32ArrayCid) {
     *last = new FloatToDoubleInstr(new Value(*last), deopt_id);
     flow_graph()->AppendTo(cursor,
                            *last,
@@ skipping 120 matching lines @@
                                     Definition::kValue);
   }
 
   StoreBarrierType needs_store_barrier = kNoStoreBarrier;
   *last = new StoreIndexedInstr(new Value(array),
                                 new Value(index),
                                 new Value(stored_value),
                                 needs_store_barrier,
                                 1,  // Index scale
                                 view_cid,
-                                call->deopt_id());
+                                call->deopt_id(),
+                                call->token_pos());
 
   flow_graph()->AppendTo(cursor,
                          *last,
                          call->deopt_id() != Isolate::kNoDeoptId ?
                             call->env() : NULL,
                          Definition::kEffect);
   return true;
 }
 
 
 
 intptr_t FlowGraphOptimizer::PrepareInlineByteArrayViewOp(
     Instruction* call,
     intptr_t array_cid,
     intptr_t view_cid,
     Definition** array,
     Definition* byte_index,
     Instruction** cursor) {
   // Insert byte_index smi check.
   *cursor = flow_graph()->AppendTo(*cursor,
                                    new CheckSmiInstr(new Value(byte_index),
-                                                     call->deopt_id()),
+                                                     call->deopt_id(),
+                                                     call->token_pos()),
                                    call->env(),
                                    Definition::kEffect);
 
   const bool is_immutable = true;
   LoadFieldInstr* length =
       new LoadFieldInstr(new Value(*array),
                          CheckArrayBoundInstr::LengthOffsetFor(array_cid),
                          Type::ZoneHandle(Type::SmiType()),
+                         call->token_pos(),
                          is_immutable);
   length->set_result_cid(kSmiCid);
   length->set_recognized_kind(
       LoadFieldInstr::RecognizedKindFromArrayCid(array_cid));
   *cursor = flow_graph()->AppendTo(*cursor,
                                    length,
                                    NULL,
                                    Definition::kValue);
 
   intptr_t element_size = FlowGraphCompiler::ElementSizeFor(array_cid);
   ConstantInstr* bytes_per_element =
       flow_graph()->GetConstant(Smi::Handle(Smi::New(element_size)));
   BinarySmiOpInstr* len_in_bytes =
       new BinarySmiOpInstr(Token::kMUL,
                            new Value(length),
                            new Value(bytes_per_element),
-                           call->deopt_id());
+                           call->deopt_id(), call->token_pos());
   *cursor = flow_graph()->AppendTo(*cursor, len_in_bytes, call->env(),
                                    Definition::kValue);
 
   ConstantInstr* length_adjustment =
       flow_graph()->GetConstant(Smi::Handle(Smi::New(
           FlowGraphCompiler::ElementSizeFor(view_cid) - 1)));
   // adjusted_length = len_in_bytes - (element_size - 1).
   BinarySmiOpInstr* adjusted_length =
       new BinarySmiOpInstr(Token::kSUB,
                            new Value(len_in_bytes),
                            new Value(length_adjustment),
-                           call->deopt_id());
+                           call->deopt_id(), call->token_pos());
   *cursor = flow_graph()->AppendTo(*cursor, adjusted_length, call->env(),
                                    Definition::kValue);
 
   // Check adjusted_length > 0.
   ConstantInstr* zero = flow_graph()->GetConstant(Smi::Handle(Smi::New(0)));
   *cursor = flow_graph()->AppendTo(*cursor,
                                    new CheckArrayBoundInstr(
                                        new Value(adjusted_length),
                                        new Value(zero),
                                        call->deopt_id()),
@@ skipping 500 matching lines @@
   } else if (recognized_kind == MethodRecognizer::kMathDoublePow) {
     // We know that first argument is double, the second is num.
     // InvokeMathCFunctionInstr requires unboxed doubles. UnboxDouble
     // instructions contain type checks and conversions to double.
     ZoneGrowableArray<Value*>* args =
         new ZoneGrowableArray<Value*>(call->ArgumentCount());
     for (intptr_t i = 0; i < call->ArgumentCount(); i++) {
       args->Add(new Value(call->ArgumentAt(i)));
     }
     InvokeMathCFunctionInstr* invoke =
-        new InvokeMathCFunctionInstr(args, call->deopt_id(), recognized_kind);
+        new InvokeMathCFunctionInstr(args,
+                                     call->deopt_id(),
+                                     recognized_kind,
+                                     call->token_pos());
     ReplaceCall(call, invoke);
   } else if (Library::PrivateCoreLibName(Symbols::ClassId()).Equals(
       String::Handle(call->function().name()))) {
     // Check for core library get:_classId.
     intptr_t cid = Class::Handle(call->function().Owner()).id();
     // Currently only implemented for a subset of classes.
     ASSERT((cid == kOneByteStringCid) || (cid == kTwoByteStringCid) ||
            (cid == kExternalOneByteStringCid) ||
            (cid == kGrowableObjectArrayCid) ||
            (cid == kImmutableArrayCid) || (cid == kArrayCid));
@@ skipping 95 matching lines @@
   const Field& field = Field::ZoneHandle(GetField(class_id, field_name));
   ASSERT(!field.IsNull());
 
   if (InstanceCallNeedsClassCheck(instr)) {
     AddReceiverCheck(instr);
   }
   StoreBarrierType needs_store_barrier = kEmitStoreBarrier;
   if (ArgIsAlways(kSmiCid, *instr->ic_data(), 1)) {
     InsertBefore(instr,
                  new CheckSmiInstr(new Value(instr->ArgumentAt(1)),
-                                   instr->deopt_id()),
+                                   instr->deopt_id(),
+                                   instr->token_pos()),
                  instr->env(),
                  Definition::kEffect);
     needs_store_barrier = kNoStoreBarrier;
   }
 
   if (field.guarded_cid() != kDynamicCid) {
     InsertBefore(instr,
                  new GuardFieldInstr(new Value(instr->ArgumentAt(1)),
                                      field,
                                      instr->deopt_id()),
                  instr->env(),
                  Definition::kEffect);
   }
 
   // Field guard was detached.
   StoreInstanceFieldInstr* store = new StoreInstanceFieldInstr(
       field,
       new Value(instr->ArgumentAt(0)),
       new Value(instr->ArgumentAt(1)),
-      needs_store_barrier);
+      needs_store_barrier,
+      instr->token_pos());
 
   if (store->IsUnboxedStore()) {
     FlowGraph::AddToGuardedFields(flow_graph_->guarded_fields(), &field);
   }
 
   // Discard the environment from the original instruction because the store
   // can't deoptimize.
   instr->RemoveEnvironment();
   ReplaceCall(instr, store);
   return true;
@@ skipping 4604 matching lines @@
 void FlowGraphOptimizer::EliminateEnvironments() {
   // After this pass we can no longer perform LICM and hoist instructions
   // that can deoptimize.
 
   flow_graph_->disallow_licm();
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     BlockEntryInstr* block = block_order_[i];
     block->RemoveEnvironment();
     for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
       Instruction* current = it.Current();
-      if (!current->CanDeoptimize()) current->RemoveEnvironment();
+      if (!current->CanDeoptimize() && !FLAG_source_lines) {

[Florian Schneider, 2014/04/29 20:04:21]

Note that this flag changes the number of uses for values used in the
environment. Therefore, it may affect performance of generated code. This is
fine since the flag is not on by default, but should be kept in mind.

[srdjan, 2014/04/30 15:00:53]

Removed since it changes code.

+        // --source-lines needs deopt environments.
+        current->RemoveEnvironment();
+      }
     }
   }
 }
 
 
 // Right now we are attempting to sink allocation only into
 // deoptimization exit. So candidate should only be used in StoreInstanceField
 // instructions that write into fields of the allocated object.
 // We do not support materialization of the object that has type arguments.
 static bool IsAllocationSinkingCandidate(AllocateObjectInstr* alloc) {
@@ skipping 159 matching lines @@
     const Class& cls,
     const ZoneGrowableArray<const Object*>& slots) {
   ZoneGrowableArray<Value*>* values =
       new ZoneGrowableArray<Value*>(slots.length());
 
   // Insert load instruction for every field.
   for (intptr_t i = 0; i < slots.length(); i++) {
     LoadFieldInstr* load = slots[i]->IsField()
         ? new LoadFieldInstr(new Value(alloc),
                              &Field::Cast(*slots[i]),
-                             AbstractType::ZoneHandle())
+                             AbstractType::ZoneHandle(),
+                             alloc->token_pos())
         : new LoadFieldInstr(new Value(alloc),
                              Smi::Cast(*slots[i]).Value(),
-                             AbstractType::ZoneHandle());
+                             AbstractType::ZoneHandle(),
+                             alloc->token_pos());
     flow_graph_->InsertBefore(
         exit, load, NULL, Definition::kValue);
     values->Add(new Value(load));
   }
 
   MaterializeObjectInstr* mat = new MaterializeObjectInstr(cls, slots, values);
   flow_graph_->InsertBefore(exit, mat, NULL, Definition::kValue);
 
   // Replace all mentions of this allocation with a newly inserted
   // MaterializeObject instruction.
@@ skipping 46 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart