Enable optimizer pipeline for DBC.

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 "platform/memory_sanitizer.h"
 #include "vm/assembler.h"
 #include "vm/deopt_instructions.h"
 #include "vm/isolate.h"
@@ skipping 71 matching lines @@
   RawObject** first = reinterpret_cast<RawObject**>(fp());
   RawObject** last = reinterpret_cast<RawObject**>(sp());
   visitor->VisitPointers(first, last);
 #endif
 }
 
 
 void StackFrame::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   ASSERT(thread() == Thread::Current());
   ASSERT(visitor != NULL);
-#if !defined(TARGET_ARCH_DBC)
   // 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.
   NoSafepointScope no_safepoint;
   Code code;
   code = LookupDartCode();
   if (!code.IsNull()) {
     // Visit the code object.
     RawObject* raw_code = code.raw();
     visitor->VisitPointer(&raw_code);
 
     // Optimized frames have a stack map. We need to visit the frame based
     // on the stack map.
     Array maps;
     maps = Array::null();
     Stackmap map;
     const uword entry = reinterpret_cast<uword>(code.instructions()->ptr()) +
                         Instructions::HeaderSize();
     map = code.GetStackmap(pc() - entry, &maps, &map);
     if (!map.IsNull()) {
+#if !defined(TARGET_ARCH_DBC)
       RawObject** first = reinterpret_cast<RawObject**>(sp());
       RawObject** last = reinterpret_cast<RawObject**>(
           fp() + (kFirstLocalSlotFromFp * kWordSize));
 
       // A stack map is present in the code object, use the stack map to
       // visit frame slots which are marked as having objects.
       //
       // The layout of the frame is (lower addresses to the right):
       // | spill slots | outgoing arguments | saved registers | slow-path args |
       // |XXXXXXXXXXXXX|--------------------|XXXXXXXXXXXXXXXXX|XXXXXXXXXXXXXXXX|
@@ skipping 24 matching lines @@
       // in the case that all slots were covered by the stack map.
       ASSERT((last + 1) >= first);
       visitor->VisitPointers(first, last);
 
       // Now visit other slots which might be part of the calling convention.
       first = reinterpret_cast<RawObject**>(
           fp() + ((kFirstLocalSlotFromFp + 1) * kWordSize));
       last = reinterpret_cast<RawObject**>(
           fp() + (kFirstObjectSlotFromFp * kWordSize));
       visitor->VisitPointers(first, last);
+#else
+      RawObject** first = reinterpret_cast<RawObject**>(fp());
+      RawObject** last = reinterpret_cast<RawObject**>(sp());
+
+      // Visit fixed prefix of the frame.
+      ASSERT((first + kFirstObjectSlotFromFp) < first);
+      visitor->VisitPointers(first + kFirstObjectSlotFromFp, first - 1);
+
+      // A stack map is present in the code object, use the stack map to
+      // visit frame slots which are marked as having objects.
+      //
+      // The layout of the frame is (lower addresses to the left):
+      // | registers | outgoing arguments |
+      // |XXXXXXXXXXX|--------------------|
+      //
+      // The DBC registers are described in the stack map.
+      // The outgoing arguments are assumed to be tagged; the number
+      // of outgoing arguments is not explicitly tracked.
+      ASSERT(map.SlowPathBitCount() == 0);
+
+      // Visit DBC registers that contain tagged values.
+      intptr_t length = map.Length();
+      for (intptr_t bit = 0; bit < length; ++bit) {
+        if (map.IsObject(bit)) {
+          visitor->VisitPointer(first + bit);
+        }
+      }
+
+      // Visit outgoing arguments.
+      if ((first + length) <= last) {
+        visitor->VisitPointers(first + length, last);
+      }
+#endif  // !defined(TARGET_ARCH_DBC)
       return;
     }
 
     // No stack map, fall through.
   }
+
+#if !defined(TARGET_ARCH_DBC)
   // For normal unoptimized Dart frames and Stub frames each slot
   // between the first and last included are tagged objects.
   RawObject** first = reinterpret_cast<RawObject**>(sp());
   RawObject** last = reinterpret_cast<RawObject**>(
       fp() + (kFirstObjectSlotFromFp * kWordSize));
-  visitor->VisitPointers(first, last);
 #else
   // On DBC stack grows upwards: fp() <= sp().
   RawObject** first = reinterpret_cast<RawObject**>(
       fp() + (kFirstObjectSlotFromFp * kWordSize));
   RawObject** last = reinterpret_cast<RawObject**>(sp());
+#endif  // !defined(TARGET_ARCH_DBC)
+
   visitor->VisitPointers(first, last);
-#endif  // !defined(TARGET_ARCH_DBC)
 }
 
 
 RawFunction* StackFrame::LookupDartFunction() const {
   const Code& code = Code::Handle(LookupDartCode());
   if (!code.IsNull()) {
     return code.function();
   }
   return Function::null();
 }
@@ skipping 329 matching lines @@
     if (deopt_instr->kind() == DeoptInstr::kCallerFp) {
       return (index - num_materializations_);
     }
   }
   UNREACHABLE();
   return 0;
 }
 
 
 }  // namespace dart