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.
+        Scanner::kNoSourcePos);
     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(),  // No type.
+                               call->token_pos());
         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.
   LoadFieldInstr* length =
       new LoadFieldInstr(new Value(*array),
                          CheckArrayBoundInstr::LengthOffsetFor(array_cid),
-                         Type::ZoneHandle(Type::SmiType()));
+                         Type::ZoneHandle(Type::SmiType()),
+                         call->token_pos());
   length->set_is_immutable(
       CheckArrayBoundInstr::IsFixedLengthArrayType(array_cid));
   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 73 matching lines @@
       String::Handle(Field::NameFromGetter(call->function_name()));
   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()));
+      AbstractType::ZoneHandle(field.type()),
+      call->token_pos());
   load->set_is_immutable(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 11 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.
   LoadFieldInstr* load = new LoadFieldInstr(
       new Value(str),
       String::length_offset(),
-      Type::ZoneHandle(Type::SmiType()));
+      Type::ZoneHandle(Type::SmiType()),
+      str->token_pos());
   load->set_result_cid(kSmiCid);
   load->set_recognized_kind(MethodRecognizer::kStringBaseLength);
   return load;
 }
 
 
 bool FlowGraphOptimizer::InlineFloat32x4Getter(InstanceCallInstr* call,
                                                MethodRecognizer::Kind getter) {
   if (!ShouldInlineSimd()) {
     return false;
@@ skipping 333 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);
 
   LoadFieldInstr* length =
       new LoadFieldInstr(new Value(*array),
                          CheckArrayBoundInstr::LengthOffsetFor(array_cid),
-                         Type::ZoneHandle(Type::SmiType()));
+                         Type::ZoneHandle(Type::SmiType()),
+                         call->token_pos());
   length->set_is_immutable(true);
   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 4606 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()) {
+        // TODO(srdjan): --source-lines needs deopt environments to get at
+        // the code for this instruction, however, leaving the environment
+        // changes code.
+        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