Fix source position for stack traces with optimized top function.

runtime/vm/intermediate_language_x64.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/globals.h"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 174 matching lines @@
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(RAX));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 static void EmitAssertBoolean(Register reg,
                               intptr_t token_pos,
+                              intptr_t deopt_id,
                               LocationSummary* locs,
                               FlowGraphCompiler* compiler) {
   // Check that the type of the value is allowed in conditional context.
   // Call the runtime if the object is not bool::true or bool::false.
   ASSERT(locs->always_calls());
   Label done;
   __ CompareObject(reg, Bool::True());
   __ j(EQUAL, &done, Assembler::kNearJump);
   __ CompareObject(reg, Bool::False());
   __ j(EQUAL, &done, Assembler::kNearJump);
 
   __ pushq(reg);  // Push the source object.
   compiler->GenerateCallRuntime(token_pos,
+                                deopt_id,
                                 kConditionTypeErrorRuntimeEntry,
                                 locs);
   // We should never return here.
   __ int3();
   __ Bind(&done);
 }
 
 
 void AssertBooleanInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register obj = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   if (!is_eliminated()) {
-    EmitAssertBoolean(obj, token_pos(), locs(), compiler);
+    EmitAssertBoolean(obj, token_pos(), deopt_id(), locs(), compiler);
   }
   ASSERT(obj == result);
 }
 
 
 LocationSummary* ArgumentDefinitionTestInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(RAX));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 void ArgumentDefinitionTestInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register saved_args_desc = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   // Push the result place holder initialized to NULL.
   __ PushObject(Object::ZoneHandle());
   __ pushq(Immediate(Smi::RawValue(formal_parameter_index())));
   __ PushObject(formal_parameter_name());
   __ pushq(saved_args_desc);
   compiler->GenerateCallRuntime(token_pos(),
+                                deopt_id(),
                                 kArgumentDefinitionTestRuntimeEntry,
                                 locs());
   __ Drop(3);
   __ popq(result);  // Pop bool result.
 }
 
 
 static Condition TokenKindToSmiCondition(Token::Kind kind) {
   switch (kind) {
     case Token::kEQ: return EQUAL;
@@ skipping 231 matching lines @@
           __ CompareObject(RAX, Bool::True());
           __ j(EQUAL, &false_label, Assembler::kNearJump);
           __ LoadObject(RAX, Bool::True());
           __ jmp(&done);
           __ Bind(&false_label);
           __ LoadObject(RAX, Bool::False());
           __ jmp(&done);
         }
       } else {
         if (branch->is_checked()) {
-          EmitAssertBoolean(RAX, token_pos, locs, compiler);
+          EmitAssertBoolean(RAX, token_pos, deopt_id, locs, compiler);
         }
         __ CompareObject(RAX, Bool::True());
         branch->EmitBranchOnCondition(compiler, cond);
       }
     }
     __ jmp(&done);
     __ Bind(&next_test);
   }
   // Fall through leads to deoptimization
   __ jmp(deopt);
@@ skipping 234 matching lines @@
   Register right = locs()->in(1).reg();
   __ pushq(left);
   __ pushq(right);
   EmitEqualityAsInstanceCall(compiler,
                              deopt_id(),
                              token_pos(),
                              Token::kEQ,  // kNE reverse occurs at branch.
                              locs(),
                              *ic_data());
   if (branch->is_checked()) {
-    EmitAssertBoolean(RAX, token_pos(), locs(), compiler);
+    EmitAssertBoolean(RAX, token_pos(), deopt_id(), locs(), compiler);
   }
   Condition branch_condition = (kind() == Token::kNE) ? NOT_EQUAL : EQUAL;
   __ CompareObject(RAX, Bool::True());
   branch->EmitBranchOnCondition(compiler, branch_condition);
 }
 
 
 LocationSummary* RelationalOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
@@ skipping 610 matching lines @@
   return summary;
 }
 
 
 void InstanceOfInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(locs()->in(0).reg() == RAX);  // Value.
   ASSERT(locs()->in(1).reg() == RCX);  // Instantiator.
   ASSERT(locs()->in(2).reg() == RDX);  // Instantiator type arguments.
 
   compiler->GenerateInstanceOf(token_pos(),
+                               deopt_id(),
                                type(),
                                negate_result(),
                                locs());
   ASSERT(locs()->out().reg() == RAX);
 }
 
 
 LocationSummary* CreateArrayInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
@@ skipping 42 matching lines @@
   Register type_arguments = locs()->in(0).reg();
   Register instantiator_type_arguments = locs()->in(1).reg();
   Register result = locs()->out().reg();
 
   // Push the result place holder initialized to NULL.
   __ PushObject(Object::ZoneHandle());
   __ PushObject(cls);
   __ pushq(type_arguments);
   __ pushq(instantiator_type_arguments);
   compiler->GenerateCallRuntime(token_pos(),
+                                deopt_id(),
                                 kAllocateObjectWithBoundsCheckRuntimeEntry,
                                 locs());
   // Pop instantiator type arguments, type arguments, and class.
   __ Drop(3);
   __ popq(result);  // Pop new instance.
 }
 
 
 LocationSummary* LoadFieldInstr::MakeLocationSummary() const {
   return LocationSummary::Make(1,
@@ skipping 52 matching lines @@
     __ cmpq(FieldAddress(instantiator_reg, TypeArguments::length_offset()),
             Immediate(Smi::RawValue(len)));
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
     __ Bind(&type_arguments_uninstantiated);
   }
   // A runtime call to instantiate the type arguments is required.
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ PushObject(type_arguments());
   __ pushq(instantiator_reg);  // Push instantiator type arguments.
   compiler->GenerateCallRuntime(token_pos(),
+                                deopt_id(),
                                 kInstantiateTypeArgumentsRuntimeEntry,
                                 locs());
   __ Drop(2);  // Drop instantiator and uninstantiated type arguments.
   __ popq(result_reg);  // Pop instantiated type arguments.
   __ Bind(&type_arguments_instantiated);
   ASSERT(instantiator_reg == result_reg);
   // 'result_reg': Instantiated type arguments.
 }
 
 
@@ skipping 154 matching lines @@
 }
 
 
 void CloneContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register context_value = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ pushq(context_value);
   compiler->GenerateCallRuntime(token_pos(),
+                                deopt_id(),
                                 kCloneContextRuntimeEntry,
                                 locs());
   __ popq(result);  // Remove argument.
   __ popq(result);  // Get result (cloned context).
 }
 
 
 LocationSummary* CatchEntryInstr::MakeLocationSummary() const {
   return LocationSummary::Make(0,
                                Location::NoLocation(),
@@ skipping 35 matching lines @@
 
 class CheckStackOverflowSlowPath : public SlowPathCode {
  public:
   explicit CheckStackOverflowSlowPath(CheckStackOverflowInstr* instruction)
       : instruction_(instruction) { }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     __ Comment("CheckStackOverflowSlowPath");
     __ Bind(entry_label());
     compiler->SaveLiveRegisters(instruction_->locs());
+    // pending_deoptimization_env_ is needed to generate a runtime call that
+    // may throw an exception.
+    ASSERT(compiler->pending_deoptimization_env_ == NULL);
+    compiler->pending_deoptimization_env_ = instruction_->env();
     compiler->GenerateCallRuntime(instruction_->token_pos(),
+                                  instruction_->deopt_id(),
                                   kStackOverflowRuntimeEntry,
                                   instruction_->locs());
+    compiler->pending_deoptimization_env_ = NULL;
     compiler->RestoreLiveRegisters(instruction_->locs());
     __ jmp(exit_label());
   }
 
  private:
   CheckStackOverflowInstr* instruction_;
 };
 
 
 void CheckStackOverflowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
@@ skipping 910 matching lines @@
 }
 
 
 LocationSummary* ThrowInstr::MakeLocationSummary() const {
   return new LocationSummary(0, 0, LocationSummary::kCall);
 }
 
 
 void ThrowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   compiler->GenerateCallRuntime(token_pos(),
+                                deopt_id(),
                                 kThrowRuntimeEntry,
                                 locs());
   __ int3();
 }
 
 
 LocationSummary* ReThrowInstr::MakeLocationSummary() const {
   return new LocationSummary(0, 0, LocationSummary::kCall);
 }
 
 
 void ReThrowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   compiler->GenerateCallRuntime(token_pos(),
+                                deopt_id(),
                                 kReThrowRuntimeEntry,
                                 locs());
   __ int3();
 }
 
 
 LocationSummary* GotoInstr::MakeLocationSummary() const {
   return new LocationSummary(0, 0, LocationSummary::kNoCall);
 }
 
@@ skipping 275 matching lines @@
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64