Re-landing of "replace TrySync with Metadata".

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 "vm/compiler.h"
@@ skipping 2133 matching lines @@
       __ popq(kResultReg);
       __ Bind(&done);
       return;
     }
   }
 
   __ Bind(&slow_path);
   const Code& stub = Code::ZoneHandle(compiler->zone(),
                                       StubCode::AllocateArray_entry()->code());
   compiler->AddStubCallTarget(stub);
-  compiler->GenerateCall(token_pos(), *StubCode::AllocateArray_entry(),
-                         RawPcDescriptors::kOther, locs());
+  compiler->GenerateCallWithDeopt(token_pos(), deopt_id(),
+                                  *StubCode::AllocateArray_entry(),
+                                  RawPcDescriptors::kOther, locs());
   __ Bind(&done);
   ASSERT(locs()->out(0).reg() == kResultReg);
 }
 
 
 LocationSummary* LoadFieldInstr::MakeLocationSummary(Zone* zone,
                                                      bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps =
       (IsUnboxedLoad() && opt) ? 1 : ((IsPotentialUnboxedLoad()) ? 2 : 0);
@@ skipping 656 matching lines @@
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     if (Assembler::EmittingComments()) {
       __ Comment("slow path smi operation");
     }
     __ Bind(entry_label());
     LocationSummary* locs = instruction_->locs();
     Register result = locs->out(0).reg();
     locs->live_registers()->Remove(Location::RegisterLocation(result));
 
     compiler->SaveLiveRegisters(locs);
+    if (instruction_->env() != NULL) {
+      Environment* env = compiler->SlowPathEnvironmentFor(instruction_);
+      compiler->pending_deoptimization_env_ = env;
+    }
     __ pushq(locs->in(0).reg());
     __ pushq(locs->in(1).reg());
     compiler->EmitMegamorphicInstanceCall(
         *instruction_->call()->ic_data(), instruction_->call()->ArgumentCount(),
         instruction_->call()->deopt_id(), instruction_->call()->token_pos(),
         locs, try_index_,
         /* slow_path_argument_count = */ 2);
     __ MoveRegister(result, RAX);
     compiler->RestoreLiveRegisters(locs);
     __ jmp(exit_label());
+    compiler->pending_deoptimization_env_ = NULL;
   }
 
  private:
   CheckedSmiOpInstr* instruction_;
   intptr_t try_index_;
 };
 
 
 LocationSummary* CheckedSmiOpInstr::MakeLocationSummary(Zone* zone,
                                                         bool opt) const {
@@ skipping 130 matching lines @@
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     if (Assembler::EmittingComments()) {
       __ Comment("slow path smi comparison");
     }
     __ Bind(entry_label());
     LocationSummary* locs = instruction_->locs();
     Register result = merged_ ? locs->temp(0).reg() : locs->out(0).reg();
     locs->live_registers()->Remove(Location::RegisterLocation(result));
 
     compiler->SaveLiveRegisters(locs);
+    if (instruction_->env() != NULL) {
+      Environment* env = compiler->SlowPathEnvironmentFor(instruction_);
+      compiler->pending_deoptimization_env_ = env;
+    }
     __ pushq(locs->in(0).reg());
     __ pushq(locs->in(1).reg());
     compiler->EmitMegamorphicInstanceCall(
         *instruction_->call()->ic_data(), instruction_->call()->ArgumentCount(),
         instruction_->call()->deopt_id(), instruction_->call()->token_pos(),
         locs, try_index_,
         /* slow_path_argument_count = */ 2);
     __ MoveRegister(result, RAX);
     compiler->RestoreLiveRegisters(locs);
+    compiler->pending_deoptimization_env_ = NULL;
     if (merged_) {
       __ CompareObject(result, Bool::True());
       __ j(EQUAL, instruction_->is_negated() ? labels_.false_label
                                              : labels_.true_label);
       __ jmp(instruction_->is_negated() ? labels_.true_label
                                         : labels_.false_label);
     } else {
       __ jmp(exit_label());
     }
   }
@@ skipping 2889 matching lines @@
  public:
   RangeErrorSlowPath(GenericCheckBoundInstr* instruction, intptr_t try_index)
       : instruction_(instruction), try_index_(try_index) {}
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     if (Assembler::EmittingComments()) {
       __ Comment("slow path check bound operation");
     }
     __ Bind(entry_label());
     LocationSummary* locs = instruction_->locs();
+    compiler->SaveLiveRegisters(locs);
     __ pushq(locs->in(0).reg());
     __ pushq(locs->in(1).reg());
     __ CallRuntime(kRangeErrorRuntimeEntry, 2);
     compiler->AddDescriptor(
         RawPcDescriptors::kOther, compiler->assembler()->CodeSize(),
         instruction_->deopt_id(), instruction_->token_pos(), try_index_);
     compiler->RecordSafepoint(locs, 2);
+    Environment* env = compiler->SlowPathEnvironmentFor(instruction_);
+    compiler->EmitCatchEntryState(env, try_index_);
     __ int3();
   }
 
  private:
   GenericCheckBoundInstr* instruction_;
   intptr_t try_index_;
 };
 
 
 void GenericCheckBoundInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   RangeErrorSlowPath* slow_path =
       new RangeErrorSlowPath(this, compiler->CurrentTryIndex());
   compiler->AddSlowPathCode(slow_path);
-
   Location length_loc = locs()->in(kLengthPos);
   Location index_loc = locs()->in(kIndexPos);
   Register length = length_loc.reg();
   Register index = index_loc.reg();
   const intptr_t index_cid = this->index()->Type()->ToCid();
   if (index_cid != kSmiCid) {
     __ BranchIfNotSmi(index, slow_path->entry_label());
   }
   __ cmpq(index, length);
   __ j(ABOVE_EQUAL, slow_path->entry_label());
@@ skipping 720 matching lines @@
   ASSERT(locs()->in(0).reg() == RAX);
   __ movq(CODE_REG, FieldAddress(RAX, Function::code_offset()));
   __ movq(RCX, FieldAddress(RAX, Function::entry_point_offset()));
 
   // RAX: Function.
   // R10: Arguments descriptor array.
   // RBX: Smi 0 (no IC data; the lazy-compile stub expects a GC-safe value).
   __ xorq(RBX, RBX);
   __ call(RCX);
   compiler->RecordSafepoint(locs());
+  compiler->EmitCatchEntryState();
   // Marks either the continuation point in unoptimized code or the
   // deoptimization point in optimized code, after call.
   const intptr_t deopt_id_after = Thread::ToDeoptAfter(deopt_id());
   if (compiler->is_optimizing()) {
     compiler->AddDeoptIndexAtCall(deopt_id_after);
   }
   // Add deoptimization continuation point after the call and before the
   // arguments are removed.
   // In optimized code this descriptor is needed for exception handling.
   compiler->AddCurrentDescriptor(RawPcDescriptors::kDeopt, deopt_id_after,
@@ skipping 69 matching lines @@
   __ Drop(1);
   __ popq(result);
 }
 
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64