Make stackmaps store their actual length.

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 6919 matching lines @@
           ASSERT(DeoptId(k) != deopt_id);
         }
         ASSERT(pc != PC(k));
       }
     }
   }
 #endif  // DEBUG
 }
 
 
-void Stackmap::SetCode(const Code& code) const {
+void Stackmap::SetCode(const dart::Code& code) const {

[srdjan, 2012/08/21 16:06:04]

Why dart:: ?

[Kevin Millikin (Google), 2012/08/22 07:34:18]

Because C++.

Class Code is shadowed by the accessor member function Stackmap::Code() so it
needs to be qualified.

The previous solution was to use a different naming scheme from the rest of the
Stackmap class for that one function.  I thought qualifying class Code in two
signatures was less intrusive.

   StorePointer(&raw_ptr()->code_, code.raw());
 }
 
 
 bool Stackmap::GetBit(intptr_t bit_index) const {
   ASSERT(InRange(bit_index));
   int byte_index = bit_index >> kBitsPerByteLog2;
   int bit_remainder = bit_index & (kBitsPerByte - 1);
   uint8_t byte_mask = 1U << bit_remainder;
   uint8_t byte = raw_ptr()->data_[byte_index];
   return (byte & byte_mask);
 }
 
 
 void Stackmap::SetBit(intptr_t bit_index, bool value) const {
   ASSERT(InRange(bit_index));
   int byte_index = bit_index >> kBitsPerByteLog2;
   int bit_remainder = bit_index & (kBitsPerByte - 1);
   uint8_t byte_mask = 1U << bit_remainder;
   uint8_t* byte_addr = &(raw_ptr()->data_[byte_index]);
   if (value) {
     *byte_addr |= byte_mask;
   } else {
     *byte_addr &= ~byte_mask;
   }
 }
 
 
 RawStackmap* Stackmap::New(intptr_t pc_offset,
-                           intptr_t length_in_bits,
+                           intptr_t length,
                            BitmapBuilder* bmap) {
   ASSERT(Object::stackmap_class() != Class::null());
   ASSERT(bmap != NULL);
   Stackmap& result = Stackmap::Handle();
-  intptr_t length_in_bytes =
-      Utils::RoundUp(length_in_bits, kBitsPerByte) / kBitsPerByte;
-  if (length_in_bytes < 0 || length_in_bytes > kMaxLengthInBytes) {
+  // Guard against integer overflow of the instance size computation.
+  intptr_t payload_size =
+      Utils::RoundUp(length, kBitsPerByte) / kBitsPerByte;
+  if (payload_size < 0 ||
+      payload_size >
+          (kSmiMax - static_cast<intptr_t>(sizeof(RawStackmap)))) {

[srdjan, 2012/08/21 16:06:04]

Add parenthesis

[Kevin Millikin (Google), 2012/08/22 07:34:18]

OK.  Incorporated in an outstanding change list.

     // This should be caught before we reach here.
     FATAL1("Fatal error in Stackmap::New: invalid length %" PRIdPTR "\n",
-           length_in_bytes);
+           length);
   }
   {
     // Stackmap data objects are associated with a code object, allocate them
     // in old generation.
     RawObject* raw = Object::Allocate(Stackmap::kClassId,
-                                      Stackmap::InstanceSize(length_in_bytes),
+                                      Stackmap::InstanceSize(length),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
-    result.set_bitmap_size_in_bytes(length_in_bytes);
+    result.SetLength(length);
   }
   // When constructing a stackmap we store the pc offset in the stackmap's
   // PC. StackmapTableBuilder::FinalizeStackmaps will replace it with the pc
   // address.
   ASSERT(pc_offset >= 0);
   result.SetPC(pc_offset);
-  for (intptr_t i = 0; i < length_in_bits; i++) {
+  for (intptr_t i = 0; i < length; ++i) {
     result.SetBit(i, bmap->Get(i));
   }
-  ASSERT(bmap->Maximum() < length_in_bits);
-  result.SetMinBitIndex(bmap->Minimum());
-  result.SetMaxBitIndex(bmap->Maximum());
+  ASSERT(bmap->Maximum() < length);
   return result.raw();
 }
 
 
-void Stackmap::set_bitmap_size_in_bytes(intptr_t value) const {
-  // This is only safe because we create a new Smi, which does not cause
-  // heap allocation.
-  raw_ptr()->bitmap_size_in_bytes_ = Smi::New(value);
-}
-
-
 const char* Stackmap::ToCString() const {
   if (IsNull()) {
     return "{null}";
   } else {
-    // Guard against integer overflow, though it is highly unlikely.
-    if (MaximumBitIndex() > kIntptrMax / 4) {
-      FATAL1("MaximumBitIndex() is unexpectedly large (%" PRIdPTR ")",
-             MaximumBitIndex());
+    const char* kFormat = "0x%" PRIxPTR ": ";
+    intptr_t fixed_length = OS::SNPrint(NULL, 0, kFormat, PC()) + 1;
+    Isolate* isolate = Isolate::Current();
+    // Guard against integer overflow in the computation of alloc_size.
+    //
+    // TODO(kmillikin): We could just truncate the string if someone
+    // tries to print a 2 billion plus entry stackmap.
+    if (Length() > (kIntptrMax - fixed_length)) {
+      FATAL1("Length() is unexpectedly large (%" PRIdPTR ")", Length());
     }
-    intptr_t index = OS::SNPrint(NULL, 0, "0x%" PRIxPTR " { ", PC());
-    intptr_t alloc_size =
-        index + ((MaximumBitIndex() + 1) * 2) + 2;  // "{ 1 0 .... }".
-    Isolate* isolate = Isolate::Current();
+    intptr_t alloc_size = fixed_length + Length();
     char* chars = isolate->current_zone()->Alloc<char>(alloc_size);
-    index = OS::SNPrint(chars, alloc_size, "0x%" PRIxPTR " { ", PC());
-    for (intptr_t i = 0; i <= MaximumBitIndex(); i++) {
-      index += OS::SNPrint((chars + index),
-                           (alloc_size - index),
-                           "%d ",
-                           IsObject(i) ? 1 : 0);
+    intptr_t index = OS::SNPrint(chars, alloc_size, kFormat, PC());
+    for (intptr_t i = 0; i < Length(); i++) {
+      chars[index++] = IsObject(i) ? '1' : '0';
     }
-    OS::SNPrint((chars + index), (alloc_size - index), "}");
+    chars[index] = '\0';
     return chars;
   }
 }
 
 
 RawString* LocalVarDescriptors::GetName(intptr_t var_index) const {
   ASSERT(var_index < Length());
   const Array& names = Array::Handle(raw_ptr()->names_);
   ASSERT(Length() == names.Length());
   const String& name = String::CheckedHandle(names.At(var_index));
@@ skipping 291 matching lines @@
   }
   ASSERT(Object::code_class() != Class::null());
   Code& result = Code::Handle();
   {
     uword size = Code::InstanceSize(pointer_offsets_length);
     RawObject* raw = Object::Allocate(Code::kClassId, size, Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.set_pointer_offsets_length(pointer_offsets_length);
     result.set_is_optimized(false);
-    result.set_spill_slot_count(0);
     result.set_comments(Comments::New(0));
   }
   return result.raw();
 }
 
 
 RawCode* Code::FinalizeCode(const char* name, Assembler* assembler) {
   ASSERT(assembler != NULL);
 
   // Allocate the Instructions object.
@@ skipping 3984 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "WeakProperty";
 }
 
 }  // namespace dart