Build and use stack maps in the SSA compiler.

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"
 #include "vm/bootstrap.h"
-#include "vm/datastream.h"
-#include "vm/deopt_instructions.h"
+#include "vm/class_finalizer.h"
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
-#include "vm/class_finalizer.h"
 #include "vm/dart.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
+#include "vm/datastream.h"
 #include "vm/debuginfo.h"
+#include "vm/deopt_instructions.h"
 #include "vm/double_conversion.h"
 #include "vm/exceptions.h"
 #include "vm/growable_array.h"
 #include "vm/heap.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/runtime_entry.h"
 #include "vm/scopes.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
@@ skipping 6518 matching lines @@
     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;
+  OS::Print("%-*s\tkind    \ttid\ttok-ix\ttry/deopt-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;
   const char* kFormat =
-      "0x%" PRIxPTR "\t%s\t%" PRIdPTR "\t%" PRIdPTR "\t%" PRIdPTR "\n";
+      "0x%-*" PRIxPTR "\t%s\t%" PRIdPTR "\t%" PRIdPTR "\t%" PRIdPTR "\n";

[Vyacheslav Egorov (Google), 2012/08/13 12:54:46]

please add a comment about *

consider making a define to fold *PRIxPTR into a fixed width format modifier,
something like

#if X64
#  define PRIxPTRW "16" PRIxPTR 
#else
#  define PRIxPTRW "8" PRIxPTR 
#endif

[Kevin Millikin (Google), 2012/08/13 15:10:37]

Blah.  I'd rather use vanilla printf specifiers than invent our own wrappers. 
I'll add a comment, though.

   // 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,
+    len += OS::SNPrint(NULL, 0, kFormat, addr_width,
         PC(i),
         KindAsStr(i),
         DeoptId(i),
         token_pos_or_deopt_reason,
         multi_purpose_index);
   }
   // 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,
+    index += OS::SNPrint((buffer + index), (len - index), kFormat, addr_width,
         PC(i),
         KindAsStr(i),
         DeoptId(i),
         token_pos_or_deopt_reason,
         multi_purpose_index);
   }
   return buffer;
 }
 
 
@@ skipping 429 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 3941 matching lines @@
 const char* JSRegExp::ToCString() const {
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart