Enable optimizer pipeline for DBC.

runtime/vm/deopt_instructions.h

Index: runtime/vm/deopt_instructions.h
diff --git a/runtime/vm/deopt_instructions.h b/runtime/vm/deopt_instructions.h
index 229a0aaec1c985cd2221ef60bf7a3624408b91f8..7b4cbe71c0c61fabc9af224ca89110b7ffd2d938 100644
--- a/runtime/vm/deopt_instructions.h
+++ b/runtime/vm/deopt_instructions.h
@@ -12,6 +12,7 @@
 #include "vm/growable_array.h"
 #include "vm/locations.h"
 #include "vm/object.h"
+#include "vm/stack_frame.h"
 #include "vm/thread.h"
 
 namespace dart {
@@ -48,6 +49,10 @@ class DeoptContext {
   intptr_t* GetSourceFrameAddressAt(intptr_t index) const {
     ASSERT(source_frame_ != NULL);
     ASSERT((0 <= index) && (index < source_frame_size_));
+#if !defined(TARGET_ARCH_DBC)
+    // Convert FP relative index to SP relative one.
+    index = source_frame_size_ - 1 - index;
+#endif  // !defined(TARGET_ARCH_DBC)
     return &source_frame_[index];
   }
 
@@ -64,25 +69,41 @@ class DeoptContext {
   }
 
   intptr_t RegisterValue(Register reg) const {
+#if !defined(TARGET_ARCH_DBC)
     ASSERT(cpu_registers_ != NULL);
     ASSERT(reg >= 0);
     ASSERT(reg < kNumberOfCpuRegisters);
     return cpu_registers_[reg];
+#else
+    // On DBC registers and stack slots are the same.
+    const intptr_t stack_index = num_args_ + kDartFrameFixedSize + reg;
+    return *GetSourceFrameAddressAt(stack_index);
+#endif  // !defined(TARGET_ARCH_DBC)
   }
 
   double FpuRegisterValue(FpuRegister reg) const {
+#if !defined(TARGET_ARCH_DBC)
     ASSERT(fpu_registers_ != NULL);
     ASSERT(reg >= 0);
     ASSERT(reg < kNumberOfFpuRegisters);
     return *reinterpret_cast<double*>(&fpu_registers_[reg]);
+#else
+    UNREACHABLE();

[Florian Schneider, 2016/05/19 13:21:39]

UNIMPLEMENTED?

[Vyacheslav Egorov (Google), 2016/05/19 15:19:40]

I think UNREACHABLE right now is a better choice - because this code can never
be reached with the current situation. 

[zra, 2016/05/19 16:24:27]

I guess it depends on whether we plan to ever unbox doubles?

+    return 0.0;
+#endif  // !defined(TARGET_ARCH_DBC)
   }
 
   simd128_value_t FpuRegisterValueAsSimd128(FpuRegister reg) const {
+#if !defined(TARGET_ARCH_DBC)
     ASSERT(fpu_registers_ != NULL);
     ASSERT(reg >= 0);
     ASSERT(reg < kNumberOfFpuRegisters);
     const float* address = reinterpret_cast<float*>(&fpu_registers_[reg]);
     return simd128_value_t().readFrom(address);
+#else
+    UNREACHABLE();

[Florian Schneider, 2016/05/19 13:21:39]

UNIMPLEMENTED?

[Vyacheslav Egorov (Google), 2016/05/19 15:19:40]

Ditto.

+    return simd128_value_t();
+#endif
   }
 
   void set_dest_frame(intptr_t* dest_frame) {
@@ -188,10 +209,18 @@ class DeoptContext {
     return deferred_objects_[idx];
   }
 
+  intptr_t num_args() const { return num_args_; }
+
  private:
   intptr_t* GetDestFrameAddressAt(intptr_t index) const {
     ASSERT(dest_frame_ != NULL);
     ASSERT((0 <= index) && (index < dest_frame_size_));
+#if defined(TARGET_ARCH_DBC)
+    // Stack on DBC is growing upwards but we record deopt commands
+    // in the same order we record them on other architectures as if
+    // the stack was growing downwards.
+    index = dest_frame_size_ - 1 - index;
+#endif  // defined(TARGET_ARCH_DBC)
     return &dest_frame_[index];
   }
 
@@ -383,7 +412,7 @@ class RegisterSource {
         context, reg()));
     } else {
       return *reinterpret_cast<T*>(context->GetSourceFrameAddressAt(
-          context->source_frame_size() - raw_index() - 1));
+          raw_index()));
     }
   }