Build and use stack maps in the SSA compiler.

runtime/vm/stack_frame.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/stack_frame.h"
 
 #include "vm/assembler_macros.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
@@ skipping 33 matching lines @@
 }
 
 
 void StackFrame::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   // NOTE: This code runs while GC is in progress and runs within
   // a NoHandleScope block. Hence it is not ok to use regular Zone or
   // Scope handles. We use direct stack handles, the raw pointers in
   // these handles are not traversed. The use of handles is mainly to
   // be able to reuse the handle based code and avoid having to add
   // helper functions to the raw object interface.
+  ASSERT(visitor != NULL);
   NoGCScope no_gc;
+  RawObject** start_addr = reinterpret_cast<RawObject**>(sp());
+  RawObject** end_addr = reinterpret_cast<RawObject**>(
+      fp() + (ParsedFunction::kFirstLocalSlotIndex * kWordSize));
   Code code;
   code = LookupDartCode();
   if (!code.IsNull()) {
     Array maps;
     maps = Array::null();
     Stackmap map;
     map = code.GetStackmap(pc(), &maps, &map);
     if (!map.IsNull()) {
       // A stack map is present in the code object, use the stack map to visit
       // frame slots which are marked as having objects.
-      intptr_t bit_index = map.MinimumBitIndex();
-      ASSERT(bit_index != Stackmap::kNoMinimum);
       intptr_t end_bit_index = map.MaximumBitIndex();
-      ASSERT(end_bit_index != Stackmap::kNoMaximum);
-      uword base_addr =
-          fp() + (ParsedFunction::kFirstLocalSlotIndex * kWordSize);
-      while (bit_index <= end_bit_index) {
-        uword addr = base_addr - (bit_index * kWordSize);
-        ASSERT(addr >= sp());
-        if (map.IsObject(bit_index)) {
-          visitor->VisitPointer(reinterpret_cast<RawObject**>(addr));
+      // It's possible that no bits are set.
+      if (end_bit_index != Stackmap::kNoMaximum) {
+        intptr_t bit_index = map.MinimumBitIndex();
+        ASSERT(bit_index != Stackmap::kNoMinimum);
+        ASSERT(bit_index <= end_bit_index);
+        ASSERT(end_bit_index <= (end_addr - start_addr));
+        while (bit_index <= end_bit_index) {
+          if (map.IsObject(bit_index)) {
+            visitor->VisitPointer(end_addr - bit_index);
+          }
+          ++bit_index;
         }
-        ++bit_index;
       }
-      return;
+      // The stack slots that are not spill slots (i.e., outgoing arguments)
+      // are tagged objects.
+      end_addr = end_addr - (code.spill_slot_count() - 1);
+      ASSERT(end_addr >= start_addr);
     }
   }
-  // No stack maps are present in the code object which means this
-  // frame relies on tagged pointers and hence we visit each entry
-  // on the frame between SP and FP.
-  ASSERT(visitor != NULL);
-  RawObject** start = reinterpret_cast<RawObject**>(sp());
-  RawObject** end = reinterpret_cast<RawObject**>(
-      fp() + (ParsedFunction::kFirstLocalSlotIndex * kWordSize));
-  visitor->VisitPointers(start, end);
+  // Each slot between the start and end address are tagged objects.
+  visitor->VisitPointers(start_addr, end_addr);

[siva, 2012/08/10 18:01:25]

I think this hybrid approach of having a stack map and treating outgoing
arguments specially is pretty confusing. It seems to spread the implementation
into multiple places and can normally leads to confusion.

I liked the earlier approach that a frame either has a stackmap which describes
it completely or just has pure tagged objects. That way the stack frame code
does not need to have any inbuilt knowledge about outgoing argument layout etc.

[Vyacheslav Egorov (Google), 2012/08/10 18:11:42]

I agree that it might be a little bit confusing and that it might be beneficial
for the debugging to have a code that verifies stack frame size but it has a
solid reasoning behind it. Current calling convention mandates that all outgoing
parameters have to be tagged so all stack maps will have a sequence of 1s at the
end which does not have to be emitted if we accept that everything above spill
slots is an outgoing parameter (and thus is tagged).

Furthermore this decision greatly simplifies implementation because our IR is
not entirely uniform in its management of the stack: some instructions push
outgoing parameters (and sometimes a null to create a space for result!)
internally on the stack while others rely on compiler to generate PushArgument
instructions (end many PushArgument instructions are removed by the optimizer).
Refactoring at this point of time might not be entirely possible because
instructions are used by two different optimization pipelines.

 }
 
 
 RawFunction* StackFrame::LookupDartFunction() const {
   const Code& code = Code::Handle(LookupDartCode());
   if (!code.IsNull()) {
     return code.function();
   }
   return Function::null();
 }
@@ skipping 147 matching lines @@
 EntryFrame* StackFrameIterator::NextEntryFrame() {
   ASSERT(!frames_.HasNext());
   entry_.sp_ = frames_.sp_;
   entry_.fp_ = frames_.fp_;
   SetupNextExitFrameData();  // Setup data for next exit frame in chain.
   ASSERT(entry_.IsValid());
   return &entry_;
 }
 
 }  // namespace dart