Remove deoptimization index PC descriptors.

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 6382 matching lines @@
   return *(EntryAddr(index, kDeoptIdEntry));
 }
 
 
 void PcDescriptors::SetDeoptId(intptr_t index, intptr_t value) const {
   *(EntryAddr(index, kDeoptIdEntry)) = value;
 }
 
 
 intptr_t PcDescriptors::TokenPos(intptr_t index) const {
-  ASSERT(DescriptorKind(index) != kDeoptIndex);
   return *(EntryAddr(index, kTokenPosEntry));
 }
 
 
 void PcDescriptors::SetTokenPos(intptr_t index, intptr_t value) const {
   *(EntryAddr(index, kTokenPosEntry)) = value;
 }
 
 
 intptr_t PcDescriptors::TryIndex(intptr_t index) const {
-  ASSERT(DescriptorKind(index) != kDeoptIndex);
   return *(EntryAddr(index, kTryIndexEntry));
 }
 
 
 void PcDescriptors::SetTryIndex(intptr_t index, intptr_t value) const {
   *(EntryAddr(index, kTryIndexEntry)) = value;
 }
 
 
-intptr_t PcDescriptors::DeoptIndex(intptr_t index) const {
-  ASSERT(DescriptorKind(index) == kDeoptIndex);
-  return *(EntryAddr(index, kDeoptIndexEntry));
-}
-
-
-intptr_t PcDescriptors::DeoptReason(intptr_t index) const {
-  ASSERT(DescriptorKind(index) == kDeoptIndex);
-  return *(EntryAddr(index, kDeoptReasonEntry));
-}
-
-
 RawPcDescriptors* PcDescriptors::New(intptr_t num_descriptors) {
   ASSERT(Object::pc_descriptors_class() != Class::null());
   if (num_descriptors < 0 || num_descriptors > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in PcDescriptors::New: "
            "invalid num_descriptors %"Pd"\n", num_descriptors);
   }
   PcDescriptors& result = PcDescriptors::Handle();
   {
     uword size = PcDescriptors::InstanceSize(num_descriptors);
     RawObject* raw = Object::Allocate(PcDescriptors::kClassId,
                                       size,
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(num_descriptors);
   }
   return result.raw();
 }
 
 
 const char* PcDescriptors::KindAsStr(intptr_t index) const {
   switch (DescriptorKind(index)) {
     case PcDescriptors::kDeoptBefore:   return "deopt-before ";
     case PcDescriptors::kDeoptAfter:    return "deopt-after  ";
-    case PcDescriptors::kDeoptIndex:    return "deopt-ix     ";
     case PcDescriptors::kPatchCode:     return "patch        ";
     case PcDescriptors::kLazyDeoptJump: return "lazy-deopt   ";
     case PcDescriptors::kIcCall:        return "ic-call      ";
     case PcDescriptors::kFuncCall:      return "fn-call      ";
     case PcDescriptors::kReturn:        return "return       ";
     case PcDescriptors::kOther:         return "other        ";
   }
   UNREACHABLE();
   return "";
 }
 
 
 void PcDescriptors::PrintHeaderString() {
   // 4 bits per hex digit + 2 for "0x".
   const int addr_width = (kBitsPerWord / 4) + 2;
   // "*" in a printf format specifier tells it to read the field width from
   // the printf argument list.
-  OS::Print("%-*s\tkind    \tdeopt-id\ttok-ix\ttry/deopt-ix\n",
+  OS::Print("%-*s\tkind    \tdeopt-id\ttok-ix\ttry-ix\n",
             addr_width, "pc");
 }
 
 
 const char* PcDescriptors::ToCString() const {
   if (Length() == 0) {
     return "No pc descriptors\n";
   }
   // 4 bits per hex digit.
   const int addr_width = kBitsPerWord / 4;
   // "*" in a printf format specifier tells it to read the field width from
   // the printf argument list.
   const char* kFormat =
       "%#-*"Px"\t%s\t%"Pd"\t%"Pd"\t%"Pd"\n";
   // First compute the buffer size required.
   intptr_t len = 1;  // Trailing '\0'.
   for (intptr_t i = 0; i < Length(); i++) {
-    intptr_t token_pos_or_deopt_reason = DescriptorKind(i) == kDeoptIndex ?
-        DeoptReason(i) : TokenPos(i);
-    intptr_t multi_purpose_index = DescriptorKind(i) == kDeoptIndex ?
-        DeoptIndex(i) : TryIndex(i);
     len += OS::SNPrint(NULL, 0, kFormat, addr_width,
-        PC(i),
-        KindAsStr(i),
-        DeoptId(i),
-        token_pos_or_deopt_reason,
-        multi_purpose_index);
+                       PC(i),
+                       KindAsStr(i),
+                       DeoptId(i),
+                       TokenPos(i),
+                       TryIndex(i));
   }
   // Allocate the buffer.
   char* buffer = Isolate::Current()->current_zone()->Alloc<char>(len);
   // Layout the fields in the buffer.
   intptr_t index = 0;
   for (intptr_t i = 0; i < Length(); i++) {
-    intptr_t token_pos_or_deopt_reason = DescriptorKind(i) == kDeoptIndex ?
-        DeoptReason(i) : TokenPos(i);
-    intptr_t multi_purpose_index = DescriptorKind(i) == kDeoptIndex ?
-        DeoptIndex(i) : TryIndex(i);
     index += OS::SNPrint((buffer + index), (len - index), kFormat, addr_width,
-        PC(i),
-        KindAsStr(i),
-        DeoptId(i),
-        token_pos_or_deopt_reason,
-        multi_purpose_index);
+                         PC(i),
+                         KindAsStr(i),
+                         DeoptId(i),
+                         TokenPos(i),
+                         TryIndex(i));
   }
   return buffer;
 }
 
 
 // Verify assumptions (in debug mode only).
 // - No two deopt descriptors have the same deoptimization id.
 // - No two ic-call descriptors have the same deoptimization id (type feedback).
 // A function without unique ids is marked as non-optimizable (e.g., because of
 // finally blocks).
@@ skipping 5622 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart