Initial SIMDBC interpreter.

runtime/vm/stack_frame.h

 // Copyright (c) 2011, 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_STACK_FRAME_H_
 #define VM_STACK_FRAME_H_
 
 #include "vm/allocation.h"
 #include "vm/object.h"
 #include "vm/stub_code.h"
 
 #if defined(TARGET_ARCH_IA32)
 #include "vm/stack_frame_ia32.h"
 #elif defined(TARGET_ARCH_X64)
 #include "vm/stack_frame_x64.h"
 #elif defined(TARGET_ARCH_ARM)
 #include "vm/stack_frame_arm.h"
 #elif defined(TARGET_ARCH_ARM64)
 #include "vm/stack_frame_arm64.h"
 #elif defined(TARGET_ARCH_MIPS)
 #include "vm/stack_frame_mips.h"
+#elif defined(TARGET_ARCH_DBC)
+#include "vm/stack_frame_dbc.h"
 #else
 #error Unknown architecture.
 #endif
 
 namespace dart {
 
 // Forward declarations.
 class ObjectPointerVisitor;
 class RawContext;
 
@@ skipping 62 matching lines @@
   Isolate* isolate() const { return thread_->isolate(); }
 
   Thread* thread() const { return thread_; }
 
  private:
   RawCode* GetCodeObject() const;
 
   uword GetCallerSp() const {
     return fp() + (kCallerSpSlotFromFp * kWordSize);
   }
+
   uword GetCallerFp() const {
     return *(reinterpret_cast<uword*>(
-        fp() + (kSavedCallerFpSlotFromFp * kWordSize)));
+      fp() + (kSavedCallerFpSlotFromFp * kWordSize)));
   }
+
   uword GetCallerPc() const {
     return *(reinterpret_cast<uword*>(
         fp() + (kSavedCallerPcSlotFromFp * kWordSize)));
   }
 
   uword fp_;
   uword sp_;
   uword pc_;
   Thread* thread_;
 
@@ skipping 63 matching lines @@
   static const bool kValidateFrames = true;
   static const bool kDontValidateFrames = false;
 
   // Iterators for iterating over all frames from the last ExitFrame to the
   // first EntryFrame.
   StackFrameIterator(bool validate,
                      Thread* thread = Thread::Current());
   StackFrameIterator(uword last_fp, bool validate,
                      Thread* thread = Thread::Current());
 
+#if !defined(TARGET_ARCH_DBC)
   // Iterator for iterating over all frames from the current frame (given by its
   // fp, sp, and pc) to the first EntryFrame.
   StackFrameIterator(uword fp, uword sp, uword pc, bool validate,
                      Thread* thread = Thread::Current());
+#endif
 
   // Checks if a next frame exists.
   bool HasNextFrame() const { return frames_.fp_ != 0; }
 
   // Get next frame.
   StackFrame* NextFrame();
 
   bool validate() const { return validate_; }
 
  private:
@@ skipping 60 matching lines @@
 // it is only allowed on Windows- where it is needed for the profiler.
 // It is the responsibility of users of DartFrameIterator to ensure that the
 // isolate given is not running concurrently on another thread.
 class DartFrameIterator : public ValueObject {
  public:
   explicit DartFrameIterator(Thread* thread = Thread::Current())
       : frames_(StackFrameIterator::kDontValidateFrames, thread) { }
   DartFrameIterator(uword last_fp,
                     Thread* thread = Thread::Current())
       : frames_(last_fp, StackFrameIterator::kDontValidateFrames, thread) { }
+
+#if !defined(TARGET_ARCH_DBC)
   DartFrameIterator(uword fp,
                     uword sp,
                     uword pc,
                     Thread* thread = Thread::Current())
       : frames_(fp, sp, pc,
                 StackFrameIterator::kDontValidateFrames, thread) {
   }
+#endif
+
   // Get next dart frame.
   StackFrame* NextFrame() {
     StackFrame* frame = frames_.NextFrame();
     while (frame != NULL && !frame->IsDartFrame(frames_.validate())) {
       frame = frames_.NextFrame();
     }
     return frame;
   }
 
  private:
@@ skipping 37 matching lines @@
   Code& code_;
   TypedData& deopt_info_;
   Function& function_;
   uword pc_;
   GrowableArray<DeoptInstr*> deopt_instructions_;
   ObjectPool& object_table_;
 
   DISALLOW_COPY_AND_ASSIGN(InlinedFunctionsIterator);
 };
 
+#if !defined(TARGET_ARCH_DBC)
+DART_FORCE_INLINE static uword LocalVarAddress(uword fp, intptr_t index) {
+  return fp + (index * kWordSize);
+}
+
+
+DART_FORCE_INLINE static uword ParamAddress(uword fp, intptr_t reverse_index) {
+  return fp + (kParamEndSlotFromFp * kWordSize) + (reverse_index * kWordSize);
+}
+
+
+DART_FORCE_INLINE static bool IsCalleeFrameOf(uword fp, uword other_fp) {
+  return other_fp < fp;
+}
+
+// Value for stack limit that is used to cause an interrupt.
+// Note that on DBC stack is growing upwards so interrupt limit is 0 unlike
+// on all other architectures.
+static const uword kInterruptStackLimit = ~static_cast<uword>(0);
+#endif
+
 }  // namespace dart
 
 #endif  // VM_STACK_FRAME_H_