Re-landing of "replace TrySync with Metadata".

runtime/vm/deopt_instructions.h

 // 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.
 
 #ifndef RUNTIME_VM_DEOPT_INSTRUCTIONS_H_
 #define RUNTIME_VM_DEOPT_INSTRUCTIONS_H_
 
 #include "vm/allocation.h"
 #include "vm/assembler.h"
+#include "vm/code_descriptors.h"
 #include "vm/code_generator.h"
 #include "vm/deferred_objects.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/growable_array.h"
 #include "vm/locations.h"
 #include "vm/object.h"
 #include "vm/stack_frame.h"
 #include "vm/thread.h"
 
 namespace dart {
@@ skipping 30 matching lines @@
   intptr_t* GetSourceFrameAddressAt(intptr_t index) const {
     ASSERT(source_frame_ != NULL);
     ASSERT((0 <= index) && (index < source_frame_size_));
 #if !defined(TARGET_ARCH_DBC)
     // Convert FP relative index to SP relative one.
     index = source_frame_size_ - 1 - index;
 #endif  // !defined(TARGET_ARCH_DBC)
     return &source_frame_[index];
   }
 
+  // Returns index in stack slot notation where -1 is the first argument
+  // For DBC returns index directly relative to FP.
+  intptr_t GetStackSlot(intptr_t index) const {
+    ASSERT((0 <= index) && (index < source_frame_size_));
+    index -= num_args_;
+#if defined(TARGET_ARCH_DBC)
+    return index < 0 ? index - kDartFrameFixedSize : index;
+#else
+    return index < 0 ? index : index - kDartFrameFixedSize;
+#endif  // defined(TARGET_ARCH_DBC)
+  }
+
   intptr_t GetSourceFp() const;
   intptr_t GetSourcePp() const;
   intptr_t GetSourcePc() const;
 
   intptr_t GetCallerFp() const;
   void SetCallerFp(intptr_t callers_fp);
 
   RawObject* ObjectAt(intptr_t index) const {
     const ObjectPool& object_pool = ObjectPool::Handle(object_pool_);
     return object_pool.ObjectAt(index);
@@ skipping 76 matching lines @@
   bool HasDeoptFlag(ICData::DeoptFlags flag) {
     return (deopt_flags_ & flag) != 0;
   }
 
   RawTypedData* deopt_info() const { return deopt_info_; }
 
   // Fills the destination frame but defers materialization of
   // objects.
   void FillDestFrame();
 
+  // Allocate and prepare exceptions metadata for TrySync
+  intptr_t* CatchEntryState(intptr_t num_vars);
+
   // Materializes all deferred objects.  Returns the total number of
   // artificial arguments used during deoptimization.
   intptr_t MaterializeDeferredObjects();
 
   RawArray* DestFrameAsArray();
 
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
   void DeferMaterializedObjectRef(intptr_t idx, intptr_t* slot) {
     deferred_slots_ = new DeferredObjectRef(
@@ skipping 98 matching lines @@
 
   intptr_t deferred_objects_count_;
   DeferredObject** deferred_objects_;
 
   const bool is_lazy_deopt_;
   const bool deoptimizing_code_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptContext);
 };
 
-
 // Represents one deopt instruction, e.g, setup return address, store object,
 // store register, etc. The target is defined by instruction's position in
 // the deopt-info array.
 class DeoptInstr : public ZoneAllocated {
  public:
   enum Kind {
     kRetAddress,
     kConstant,
     kWord,
     kDouble,
@@ skipping 27 matching lines @@
     if (args != NULL) {
       return Thread::Current()->zone()->PrintToString(
           "%s(%s)", KindToCString(kind()), args);
     } else {
       return KindToCString(kind());
     }
   }
 
   virtual void Execute(DeoptContext* deopt_context, intptr_t* dest_addr) = 0;
 
+  // Convert DeoptInstr to TrySync metadata entry.
+  virtual CatchEntryStatePair ToCatchEntryStatePair(DeoptContext* deopt_context,
+                                                    intptr_t dest_slot) {
+    UNREACHABLE();
+    return CatchEntryStatePair();
+  }
+
   virtual DeoptInstr::Kind kind() const = 0;
 
   bool Equals(const DeoptInstr& other) const {
     return (kind() == other.kind()) && (source_index() == other.source_index());
   }
 
   // Get the code and return address which is encoded in this
   // kRetAfterAddress deopt instruction.
   static uword GetRetAddress(DeoptInstr* instr,
                              const ObjectPool& object_pool,
@@ skipping 73 matching lines @@
   T Value(DeoptContext* context) const {
     if (is_register()) {
       return static_cast<T>(
           RegisterReader<RegisterType, T>::Read(context, reg()));
     } else {
       return *reinterpret_cast<T*>(
           context->GetSourceFrameAddressAt(raw_index()));
     }
   }
 
+  intptr_t StackSlot(DeoptContext* context) const {
+    if (is_register()) {
+      return raw_index();  // in DBC stack slots are registers.
+    } else {
+      return context->GetStackSlot(raw_index());
+    }
+  }
+
   intptr_t source_index() const { return source_index_; }
 
   const char* ToCString() const {
     if (is_register()) {
       return Name(reg());
     } else {
       return Thread::Current()->zone()->PrintToString("s%" Pd "", raw_index());
     }
   }
 
@@ skipping 147 matching lines @@
   class ReasonField : public BitField<intptr_t, ICData::DeoptReasonId, 0, 8> {};
   class FlagsField : public BitField<intptr_t, uint32_t, 8, 8> {};
 
  private:
   static const intptr_t kEntrySize = 3;
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_DEOPT_INSTRUCTIONS_H_