Ensure that all goto instructions have deoptimization target.

runtime/vm/deopt_instructions.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/deopt_instructions.h"
 
 #include "vm/assembler.h"
 #include "vm/code_patcher.h"
 #include "vm/intermediate_language.h"
 #include "vm/locations.h"
@@ skipping 225 matching lines @@
   }
 
  private:
   const intptr_t stack_slot_index_;  // First argument is 0, always >= 0.
 
   DISALLOW_COPY_AND_ASSIGN(DeoptUint32x4StackSlotInstr);
 };
 
 
 // Deoptimization instruction creating return address using function and
-// deopt-id stored at 'object_table_index'. Uses the deopt-after
-// continuation point.
-class DeoptRetAfterAddressInstr : public DeoptInstr {
+// deopt-id stored at 'object_table_index'.
+class DeoptRetAddressInstr : public DeoptInstr {
  public:
-  DeoptRetAfterAddressInstr(intptr_t object_table_index, intptr_t deopt_id)
+  DeoptRetAddressInstr(intptr_t object_table_index, intptr_t deopt_id)
       : object_table_index_(object_table_index), deopt_id_(deopt_id) {
     ASSERT(object_table_index >= 0);
     ASSERT(deopt_id >= 0);
   }
 
-  explicit DeoptRetAfterAddressInstr(intptr_t from_index)
+  explicit DeoptRetAddressInstr(intptr_t from_index)
       : object_table_index_(ObjectTableIndex::decode(from_index)),
         deopt_id_(DeoptId::decode(from_index)) {
   }
 
   virtual intptr_t from_index() const {
     return ObjectTableIndex::encode(object_table_index_) |
         DeoptId::encode(deopt_id_);
   }
-  virtual DeoptInstr::Kind kind() const { return kRetAfterAddress; }
+
+  virtual DeoptInstr::Kind kind() const { return kRetAddress; }
 
   virtual const char* ToCString() const {
-    const char* format = "ret aft oti:%"Pd"(%"Pd")";
-    intptr_t len = OS::SNPrint(NULL, 0, format, object_table_index_, deopt_id_);
-    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
-    OS::SNPrint(chars, len + 1, format, object_table_index_, deopt_id_);
-    return chars;
+    return Isolate::Current()->current_zone()->PrintToString(
+        "ret oti:%"Pd"(%"Pd")", object_table_index_, deopt_id_);
   }
 
   void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
-    Function& function = Function::Handle(deopt_context->isolate());
-    function ^= deopt_context->ObjectAt(object_table_index_);
-    const Code& code =
-        Code::Handle(deopt_context->isolate(), function.unoptimized_code());
-    ASSERT(!code.IsNull());
-    uword continue_at_pc = code.GetDeoptAfterPcAtDeoptId(deopt_id_);
-    ASSERT(continue_at_pc != 0);
-    intptr_t* to_addr = deopt_context->GetToFrameAddressAt(to_index);
-    *to_addr = continue_at_pc;
-  }
-
-  intptr_t object_table_index() const { return object_table_index_; }
-  intptr_t deopt_id() const { return deopt_id_; }
-
- private:
-  static const intptr_t kFieldWidth = kBitsPerWord / 2;
-  class ObjectTableIndex : public BitField<intptr_t, 0, kFieldWidth> { };
-  class DeoptId : public BitField<intptr_t, kFieldWidth, kFieldWidth> { };
-
-  const intptr_t object_table_index_;
-  const intptr_t deopt_id_;
-
-  DISALLOW_COPY_AND_ASSIGN(DeoptRetAfterAddressInstr);
-};
-
-
-// Deoptimization instruction creating return address using function and
-// deopt-id stored at 'object_table_index'. Uses the deopt-before
-// continuation point.
-class DeoptRetBeforeAddressInstr : public DeoptInstr {
- public:
-  DeoptRetBeforeAddressInstr(intptr_t object_table_index, intptr_t deopt_id)
-      : object_table_index_(object_table_index), deopt_id_(deopt_id) {
-    ASSERT(object_table_index >= 0);
-    ASSERT(deopt_id >= 0);
-  }
-
-  explicit DeoptRetBeforeAddressInstr(intptr_t from_index)
-      : object_table_index_(ObjectTableIndex::decode(from_index)),
-        deopt_id_(DeoptId::decode(from_index)) {
-  }
-
-  virtual intptr_t from_index() const {
-    return ObjectTableIndex::encode(object_table_index_) |
-        DeoptId::encode(deopt_id_);
-  }
-  virtual DeoptInstr::Kind kind() const { return kRetBeforeAddress; }
-
-  virtual const char* ToCString() const {
-    const char* format = "ret bef oti:%"Pd"(%"Pd")";
-    intptr_t len = OS::SNPrint(NULL, 0, format, object_table_index_, deopt_id_);
-    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
-    OS::SNPrint(chars, len + 1, format, object_table_index_, deopt_id_);
-    return chars;
-  }
-
-  void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
     Function& function = Function::Handle(deopt_context->isolate());
     function ^= deopt_context->ObjectAt(object_table_index_);
     const Code& code =
         Code::Handle(deopt_context->isolate(), function.unoptimized_code());
     ASSERT(!code.IsNull());
-    uword continue_at_pc = code.GetDeoptBeforePcAtDeoptId(deopt_id_);
+    uword continue_at_pc = code.GetPcForDeoptId(deopt_id_,
+                                                PcDescriptors::kDeopt);
     ASSERT(continue_at_pc != 0);
     intptr_t* to_addr = deopt_context->GetToFrameAddressAt(to_index);
     *to_addr = continue_at_pc;
 
     uword pc = code.GetPcForDeoptId(deopt_id_, PcDescriptors::kIcCall);
     if (pc != 0) {
       // If the deoptimization happened at an IC call, update the IC data
       // to avoid repeated deoptimization at the same site next time around.
       ICData& ic_data = ICData::Handle();
       CodePatcher::GetInstanceCallAt(pc, code, &ic_data, NULL);
       if (!ic_data.IsNull()) {
         ic_data.set_deopt_reason(deopt_context->deopt_reason());
       }
     }
   }
 
+  intptr_t object_table_index() const { return object_table_index_; }
+  intptr_t deopt_id() const { return deopt_id_; }
+
  private:
   static const intptr_t kFieldWidth = kBitsPerWord / 2;
   class ObjectTableIndex : public BitField<intptr_t, 0, kFieldWidth> { };
   class DeoptId : public BitField<intptr_t, kFieldWidth, kFieldWidth> { };
 
   const intptr_t object_table_index_;
   const intptr_t deopt_id_;
 
-  DISALLOW_COPY_AND_ASSIGN(DeoptRetBeforeAddressInstr);
+  DISALLOW_COPY_AND_ASSIGN(DeoptRetAddressInstr);
 };
 
 
 // Deoptimization instruction moving a constant stored at 'object_table_index'.
 class DeoptConstantInstr : public DeoptInstr {
  public:
   explicit DeoptConstantInstr(intptr_t object_table_index)
       : object_table_index_(object_table_index) {
     ASSERT(object_table_index >= 0);
   }
@@ skipping 332 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(DeoptSuffixInstr);
 };
 
 
 intptr_t DeoptInstr::DecodeSuffix(intptr_t from_index, intptr_t* info_number) {
   *info_number = DeoptSuffixInstr::InfoNumber::decode(from_index);
   return DeoptSuffixInstr::SuffixLength::decode(from_index);
 }
 
 
-uword DeoptInstr::GetRetAfterAddress(DeoptInstr* instr,
-                                     const Array& object_table,
-                                     Function* func) {
-  ASSERT(instr->kind() == kRetAfterAddress);
-  DeoptRetAfterAddressInstr* ret_after_instr =
-      static_cast<DeoptRetAfterAddressInstr*>(instr);
+uword DeoptInstr::GetRetAddress(DeoptInstr* instr,
+                                const Array& object_table,
+                                Function* func) {
+  ASSERT(instr->kind() == kRetAddress);
+  DeoptRetAddressInstr* ret_address_instr =
+      static_cast<DeoptRetAddressInstr*>(instr);
+  ASSERT(Isolate::IsDeoptAfter(ret_address_instr->deopt_id()));
   ASSERT(!object_table.IsNull());
   ASSERT(func != NULL);
-  *func ^= object_table.At(ret_after_instr->object_table_index());
+  *func ^= object_table.At(ret_address_instr->object_table_index());
   const Code& code = Code::Handle(func->unoptimized_code());
   ASSERT(!code.IsNull());
-  uword res = code.GetDeoptAfterPcAtDeoptId(ret_after_instr->deopt_id());
+  uword res = code.GetPcForDeoptId(ret_address_instr->deopt_id(),
+                                   PcDescriptors::kDeopt);
   ASSERT(res != 0);
   return res;
 }
 
 
 DeoptInstr* DeoptInstr::Create(intptr_t kind_as_int, intptr_t from_index) {
   Kind kind = static_cast<Kind>(kind_as_int);
   switch (kind) {
     case kStackSlot: return new DeoptStackSlotInstr(from_index);
     case kDoubleStackSlot: return new DeoptDoubleStackSlotInstr(from_index);
     case kInt64StackSlot: return new DeoptInt64StackSlotInstr(from_index);
     case kFloat32x4StackSlot:
         return new DeoptFloat32x4StackSlotInstr(from_index);
     case kUint32x4StackSlot:
         return new DeoptUint32x4StackSlotInstr(from_index);
-    case kRetAfterAddress: return new DeoptRetAfterAddressInstr(from_index);
-    case kRetBeforeAddress: return new DeoptRetBeforeAddressInstr(from_index);
+    case kRetAddress: return new DeoptRetAddressInstr(from_index);
     case kConstant: return new DeoptConstantInstr(from_index);
     case kRegister: return new DeoptRegisterInstr(from_index);
     case kFpuRegister: return new DeoptFpuRegisterInstr(from_index);
     case kInt64FpuRegister: return new DeoptInt64FpuRegisterInstr(from_index);
     case kFloat32x4FpuRegister:
         return new DeoptFloat32x4FpuRegisterInstr(from_index);
     case kUint32x4FpuRegister:
         return new DeoptUint32x4FpuRegisterInstr(from_index);
     case kPcMarker: return new DeoptPcMarkerInstr(from_index);
     case kCallerFp: return new DeoptCallerFpInstr();
@@ skipping 52 matching lines @@
       return i;
     }
   }
   // Add object.
   const intptr_t result = object_table_.Length();
   object_table_.Add(obj);
   return result;
 }
 
 
-void DeoptInfoBuilder::AddReturnAddressBefore(const Function& function,
-                                              intptr_t deopt_id,
-                                              intptr_t to_index) {
+void DeoptInfoBuilder::AddReturnAddress(const Function& function,
+                                        intptr_t deopt_id,
+                                        intptr_t to_index) {
   // Check that deopt_id exists.
-  ASSERT(Code::Handle(function.unoptimized_code()).
-      GetDeoptBeforePcAtDeoptId(deopt_id) != 0);
+  // TODO(vegorov): verify after deoptimization targets as well.
+#ifdef DEBUG
+  const Code& code = Code::Handle(function.unoptimized_code());
+  ASSERT(Isolate::IsDeoptAfter(deopt_id) ||
+      (code.GetPcForDeoptId(deopt_id, PcDescriptors::kDeopt) != 0));
+#endif
   const intptr_t object_table_index = FindOrAddObjectInTable(function);
   ASSERT(to_index == instructions_.length());
-  instructions_.Add(new DeoptRetBeforeAddressInstr(object_table_index,
-                                                   deopt_id));
+  instructions_.Add(new DeoptRetAddressInstr(object_table_index, deopt_id));
 }
 
 
-void DeoptInfoBuilder::AddReturnAddressAfter(const Function& function,
-                                             intptr_t deopt_id,
-                                             intptr_t to_index) {
-  const intptr_t object_table_index = FindOrAddObjectInTable(function);
-  ASSERT(to_index == instructions_.length());
-  instructions_.Add(new DeoptRetAfterAddressInstr(object_table_index,
-                                                  deopt_id));
-}
-
-
 void DeoptInfoBuilder::AddPcMarker(const Function& function,
                                    intptr_t to_index) {
   // Function object was already added by AddReturnAddress, find it.
   intptr_t from_index = FindOrAddObjectInTable(function);
   ASSERT(to_index == instructions_.length());
   instructions_.Add(new DeoptPcMarkerInstr(from_index));
 }
 
 
 void DeoptInfoBuilder::AddCopy(const Location& from_loc,
@@ skipping 122 matching lines @@
                           Smi* offset,
                           DeoptInfo* info,
                           Smi* reason) {
   intptr_t i = index * kEntrySize;
   *offset ^= table.At(i);
   *info ^= table.At(i + 1);
   *reason ^= table.At(i + 2);
 }
 
 }  // namespace dart