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

runtime/vm/flow_graph_builder.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/class_finalizer.h"
@@ skipping 699 matching lines @@
 Definition* EffectGraphVisitor::BuildStoreLocal(const LocalVariable& local,
                                                 Value* value) {
   if (local.is_captured()) {
     LocalVariable* tmp_var = EnterTempLocalScope(value);
     intptr_t delta =
         owner()->context_level() - local.owner()->context_level();
     ASSERT(delta >= 0);
     Value* context = Bind(new CurrentContextInstr());
     while (delta-- > 0) {
       context = Bind(new LoadFieldInstr(
-          context, Context::parent_offset(), Type::ZoneHandle()));
+          context, Context::parent_offset(), Type::ZoneHandle(), kNoTokenPos));
     }
     Value* tmp_val = Bind(new LoadLocalInstr(*tmp_var));
     StoreInstanceFieldInstr* store =
         new StoreInstanceFieldInstr(Context::variable_offset(local.index()),
                                     context,
                                     tmp_val,
-                                    kEmitStoreBarrier);
+                                    kEmitStoreBarrier,
+                                    kNoTokenPos);
     Do(store);
     return ExitTempLocalScope(tmp_var);
   } else {
     return new StoreLocalInstr(local, value);
   }
 }
 
 
 Definition* EffectGraphVisitor::BuildLoadLocal(const LocalVariable& local) {
   if (local.IsConst()) {
     return new ConstantInstr(*local.ConstValue());
   } else if (local.is_captured()) {
     intptr_t delta =
         owner()->context_level() - local.owner()->context_level();
     ASSERT(delta >= 0);
     Value* context = Bind(new CurrentContextInstr());
     while (delta-- > 0) {
       context = Bind(new LoadFieldInstr(
-          context, Context::parent_offset(), Type::ZoneHandle()));
+          context, Context::parent_offset(), Type::ZoneHandle(), kNoTokenPos));
     }
     return new LoadFieldInstr(context,
                               Context::variable_offset(local.index()),
-                              local.type());
+                              local.type(),
+                              kNoTokenPos);
   } else {
     return new LoadLocalInstr(local);
   }
 }
 
 
 // Stores current context into the 'variable'
 void EffectGraphVisitor::BuildSaveContext(const LocalVariable& variable) {
   Value* context = Bind(new CurrentContextInstr());
   Do(BuildStoreLocal(variable, context));
@@ skipping 1381 matching lines @@
       ValueGraphVisitor for_value(owner());
       node->ElementAt(i)->Visit(&for_value);
       Append(for_value);
       // No store barrier needed for constants.
       const StoreBarrierType emit_store_barrier =
           for_value.value()->BindsToConstant()
               ? kNoStoreBarrier
               : kEmitStoreBarrier;
       intptr_t index_scale = FlowGraphCompiler::ElementSizeFor(class_id);
       StoreIndexedInstr* store = new StoreIndexedInstr(
-          array, index, for_value.value(),
-          emit_store_barrier, index_scale, class_id, deopt_id);
+          array, index, for_value.value(), emit_store_barrier,
+          index_scale, class_id, deopt_id, node->token_pos());
       Do(store);
     }
     ReturnDefinition(ExitTempLocalScope(tmp_var));
   }
 }
 
 
 void EffectGraphVisitor::VisitStringInterpolateNode(
     StringInterpolateNode* node) {
   ValueGraphVisitor for_argument(owner());
@@ skipping 75 matching lines @@
 
   Value* closure_val = Bind(alloc);
   { LocalVariable* closure_tmp_var = EnterTempLocalScope(closure_val);
     // Store function.
     Value* closure_tmp_val = Bind(new LoadLocalInstr(*closure_tmp_var));
     Value* func_val =
         Bind(new ConstantInstr(Function::ZoneHandle(function.raw())));
     Do(new StoreInstanceFieldInstr(Closure::function_offset(),
                                    closure_tmp_val,
                                    func_val,
-                                   kEmitStoreBarrier));
+                                   kEmitStoreBarrier,
+                                   node->token_pos()));
     if (is_implicit) {
       // Create new context containing the receiver.
       const intptr_t kNumContextVariables = 1;  // The receiver.
       Value* allocated_context =
           Bind(new AllocateContextInstr(node->token_pos(),
                                         kNumContextVariables));
       { LocalVariable* context_tmp_var = EnterTempLocalScope(allocated_context);
         // Store receiver in context.
         Value* context_tmp_val = Bind(new LoadLocalInstr(*context_tmp_var));
         ValueGraphVisitor for_receiver(owner());
         node->receiver()->Visit(&for_receiver);
         Append(for_receiver);
         Value* receiver = for_receiver.value();
         Do(new StoreInstanceFieldInstr(Context::variable_offset(0),
                                        context_tmp_val,
                                        receiver,
-                                       kEmitStoreBarrier));
+                                       kEmitStoreBarrier,
+                                       node->token_pos()));
         // Store new context in closure.
         closure_tmp_val = Bind(new LoadLocalInstr(*closure_tmp_var));
         context_tmp_val = Bind(new LoadLocalInstr(*context_tmp_var));
         Do(new StoreInstanceFieldInstr(Closure::context_offset(),
                                        closure_tmp_val,
                                        context_tmp_val,
-                                       kEmitStoreBarrier));
+                                       kEmitStoreBarrier,
+                                       node->token_pos()));
         Do(ExitTempLocalScope(context_tmp_var));
       }
     } else {
       // Store current context in closure.
       closure_tmp_val = Bind(new LoadLocalInstr(*closure_tmp_var));
       Value* context = Bind(new CurrentContextInstr());
       Do(new StoreInstanceFieldInstr(Closure::context_offset(),
                                      closure_tmp_val,
                                      context,
-                                     kEmitStoreBarrier));
+                                     kEmitStoreBarrier,
+                                     node->token_pos()));
     }
     ReturnDefinition(ExitTempLocalScope(closure_tmp_var));
   }
 }
 
 
 void EffectGraphVisitor::BuildPushArguments(
     const ArgumentListNode& node,
     ZoneGrowableArray<PushArgumentInstr*>* values) {
   for (intptr_t i = 0; i < node.length(); ++i) {
@@ skipping 294 matching lines @@
   // The receiver cannot be null; extract its TypeArguments object.
   // Note that in the factory case, the instantiator is the first parameter
   // of the factory, i.e. already a TypeArguments object.
   intptr_t type_arguments_field_offset =
       instantiator_class.type_arguments_field_offset();
   ASSERT(type_arguments_field_offset != Class::kNoTypeArguments);
 
   return Bind(new LoadFieldInstr(
       instantiator,
       type_arguments_field_offset,
-      Type::ZoneHandle()));  // Not an instance, no type.
+      Type::ZoneHandle(),  // Not an instance, no type.
+      kNoTokenPos));
 }
 
 
 Value* EffectGraphVisitor::BuildInstantiatedTypeArguments(
     intptr_t token_pos,
     const TypeArguments& type_arguments) {
   if (type_arguments.IsNull() || type_arguments.IsInstantiated()) {
     return Bind(new ConstantInstr(type_arguments));
   }
   // The type arguments are uninstantiated.
@@ skipping 328 matching lines @@
         Value* receiver = Bind(BuildLoadThisVar(node->scope()));
         // 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(
             receiver,
             String::length_offset(),
             Type::ZoneHandle(Type::SmiType()),
+            node->token_pos(),
             is_immutable);
         load->set_result_cid(kSmiCid);
         load->set_recognized_kind(MethodRecognizer::kStringBaseLength);
         if (kind == MethodRecognizer::kStringBaseLength) {
           return ReturnDefinition(load);
         }
         ASSERT(kind == MethodRecognizer::kStringBaseIsEmpty);
         Value* zero_val = Bind(new ConstantInstr(Smi::ZoneHandle(Smi::New(0))));
         Value* load_val = Bind(load);
         StrictCompareInstr* compare =
             new StrictCompareInstr(node->token_pos(),
                                    Token::kEQ_STRICT,
                                    load_val,
                                    zero_val,
                                    false);  // No number check.
         return ReturnDefinition(compare);
       }
       case MethodRecognizer::kGrowableArrayLength:
       case MethodRecognizer::kObjectArrayLength:
       case MethodRecognizer::kImmutableArrayLength:
       case MethodRecognizer::kTypedDataLength: {
         Value* receiver = Bind(BuildLoadThisVar(node->scope()));
         const bool is_immutable =
             (kind != MethodRecognizer::kGrowableArrayLength);
         LoadFieldInstr* load = new LoadFieldInstr(
             receiver,
             OffsetForLengthGetter(kind),
             Type::ZoneHandle(Type::SmiType()),
+            node->token_pos(),
             is_immutable);
         load->set_result_cid(kSmiCid);
         load->set_recognized_kind(kind);
         return ReturnDefinition(load);
       }
       case MethodRecognizer::kObjectCid:
       case MethodRecognizer::kTypedListBaseCid: {
         Value* receiver = Bind(BuildLoadThisVar(node->scope()));
         LoadClassIdInstr* load = new LoadClassIdInstr(receiver);
         return ReturnDefinition(load);
       }
       case MethodRecognizer::kGrowableArrayCapacity: {
         Value* receiver = Bind(BuildLoadThisVar(node->scope()));
         LoadFieldInstr* data_load = new LoadFieldInstr(
             receiver,
             Array::data_offset(),
-            Type::ZoneHandle(Type::DynamicType()));
+            Type::ZoneHandle(Type::DynamicType()),
+            node->token_pos());
         data_load->set_result_cid(kArrayCid);
         Value* data = Bind(data_load);
         LoadFieldInstr* length_load = new LoadFieldInstr(
             data,
             Array::length_offset(),
-            Type::ZoneHandle(Type::SmiType()));
+            Type::ZoneHandle(Type::SmiType()),
+            node->token_pos());
         length_load->set_result_cid(kSmiCid);
         length_load->set_recognized_kind(MethodRecognizer::kObjectArrayLength);
         return ReturnDefinition(length_load);
       }
       default:
         break;
     }
   }
   InlineBailout("EffectGraphVisitor::VisitNativeBodyNode");
   NativeCallInstr* native_call = new NativeCallInstr(node);
@@ skipping 47 matching lines @@
 
 
 void EffectGraphVisitor::VisitLoadInstanceFieldNode(
     LoadInstanceFieldNode* node) {
   ValueGraphVisitor for_instance(owner());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
   LoadFieldInstr* load = new LoadFieldInstr(
       for_instance.value(),
       &node->field(),
-      AbstractType::ZoneHandle(node->field().type()));
+      AbstractType::ZoneHandle(node->field().type()),
+      node->token_pos());
   if (node->field().guarded_cid() != kIllegalCid) {
     if (!node->field().is_nullable() ||
         (node->field().guarded_cid() == kNullCid)) {
       load->set_result_cid(node->field().guarded_cid());
     }
     FlowGraph::AddToGuardedFields(owner()->guarded_fields(), &node->field());
   }
   ReturnDefinition(load);
 }
 
@@ skipping 22 matching lines @@
                           node->field(),
                           Isolate::Current()->GetNextDeoptId());
   AddInstruction(guard);
 
   store_value = Bind(BuildLoadExprTemp());
   StoreInstanceFieldInstr* store =
       new StoreInstanceFieldInstr(node->field(),
                                   for_instance.value(),
                                   store_value,
                                   kEmitStoreBarrier,
+                                  node->token_pos(),
                                   true);  // Maybe initializing store.
   ReturnDefinition(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadStaticFieldNode(LoadStaticFieldNode* node) {
   if (node->field().is_const()) {
     ASSERT(node->field().value() != Object::sentinel().raw());
     ASSERT(node->field().value() != Object::transition_sentinel().raw());
     Definition* result =
@@ skipping 216 matching lines @@
 }
 
 
 void EffectGraphVisitor::UnchainContexts(intptr_t n) {
   if (n > 0) {
     Value* context = Bind(new CurrentContextInstr());
     while (n-- > 0) {
       context = Bind(
           new LoadFieldInstr(context,
                              Context::parent_offset(),
-                             Type::ZoneHandle()));  // Not an instance, no type.
+                             Type::ZoneHandle(),
+                             kNoTokenPos));  // Not an instance, no type.
     }
     AddInstruction(new StoreContextInstr(context));
   }
 }
 
 
 // <Statement> ::= Sequence { scope: LocalScope
 //                            nodes: <Statement>*
 //                            label: SourceLabel }
 void EffectGraphVisitor::VisitSequenceNode(SequenceNode* node) {
@@ skipping 24 matching lines @@
       if (MustSaveRestoreContext(node)) {
         BuildSaveContext(
             *owner()->parsed_function()->saved_entry_context_var());
         parent_context = Bind(new ConstantInstr(Object::ZoneHandle()));
       } else {
         parent_context = Bind(new CurrentContextInstr());
       }
       Do(new StoreInstanceFieldInstr(Context::parent_offset(),
                                      tmp_val,
                                      parent_context,
-                                     kEmitStoreBarrier));
+                                     kEmitStoreBarrier,
+                                     kNoTokenPos));
       AddInstruction(
           new StoreContextInstr(Bind(ExitTempLocalScope(tmp_var))));
     }
 
     // If this node_sequence is the body of the function being compiled, copy
     // the captured parameters from the frame into the context.
     if (node == owner()->parsed_function()->node_sequence()) {
       ASSERT(scope->context_level() == 1);
       const Function& function = owner()->parsed_function()->function();
       const int num_params = function.NumParameters();
@@ skipping 458 matching lines @@
                                   function.token_pos(),
                                   LanguageError::kError,
                                   Heap::kNew,
                                   "FlowGraphBuilder Bailout: %s %s",
                                   String::Handle(function.name()).ToCString(),
                                   reason));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 }  // namespace dart