Enable optimizer pipeline for DBC.

runtime/vm/deopt_instructions.h

 // Copyright (c) 2013, 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.
 
 #ifndef VM_DEOPT_INSTRUCTIONS_H_
 #define VM_DEOPT_INSTRUCTIONS_H_
 
 #include "vm/allocation.h"
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
 #include "vm/deferred_objects.h"
 #include "vm/growable_array.h"
 #include "vm/locations.h"
 #include "vm/object.h"
+#include "vm/stack_frame.h"
 #include "vm/thread.h"
 
 namespace dart {
 
 class Location;
 class Value;
 class MaterializeObjectInstr;
 class StackFrame;
 class TimelineEvent;
 
@@ skipping 16 matching lines @@
                bool deoptimizing_code);
   virtual ~DeoptContext();
 
   // Returns the offset of the dest fp from the dest sp.  Used in
   // runtime code to adjust the stack size before deoptimization.
   intptr_t DestStackAdjustment() const;
 
   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];
   }
 
   intptr_t GetSourceFp() const;
   intptr_t GetSourcePp() const;
   intptr_t GetSourcePc() const;
 
   intptr_t GetCallerFp() const;
   void SetCallerFp(intptr_t callers_fp);
 
   RawObject* ObjectAt(intptr_t index) const {
     const ObjectPool& object_pool = ObjectPool::Handle(object_pool_);
     return object_pool.ObjectAt(index);
   }
 
   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) {
     ASSERT(dest_frame != NULL && dest_frame_ == NULL);
     dest_frame_ = dest_frame;
   }
 
   Thread* thread() const { return thread_; }
   Zone* zone() const { return thread_->zone(); }
 
@@ skipping 85 matching lines @@
   }
 
   void DeferPpMaterialization(intptr_t index, RawObject** slot) {
     deferred_slots_ = new DeferredPp(index, slot, deferred_slots_);
   }
 
   DeferredObject* GetDeferredObject(intptr_t idx) const {
     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];
   }
 
   void PrepareForDeferredMaterialization(intptr_t count) {
     if (count > 0) {
       deferred_objects_ = new DeferredObject*[count];
       deferred_objects_count_ = count;
     }
   }
 
@@ skipping 171 matching lines @@
       : source_index_(KindField::encode(kind) | RawIndexField::encode(index)) {
   }
 
   template<typename T>
   T Value(DeoptContext* context) const {
     if (is_register()) {
       return static_cast<T>(RegisterReader<RegisterType, T>::Read(
         context, reg()));
     } else {
       return *reinterpret_cast<T*>(context->GetSourceFrameAddressAt(
-          context->source_frame_size() - raw_index() - 1));
+          raw_index()));
     }
   }
 
   intptr_t source_index() const { return source_index_; }
 
   const char* ToCString() const {
     if (is_register()) {
       return Name(reg());
     } else {
       return Thread::Current()->zone()->PrintToString(
@@ skipping 154 matching lines @@
       public BitField<intptr_t, ICData::DeoptReasonId, 0, 8> { };
   class FlagsField : public BitField<intptr_t, uint32_t, 8, 8> { };
 
  private:
   static const intptr_t kEntrySize = 3;
 };
 
 }  // namespace dart
 
 #endif  // VM_DEOPT_INSTRUCTIONS_H_