Initial SIMDBC interpreter.

runtime/vm/code_generator.cc

 // 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.
 
 #include "vm/code_generator.h"
 
 #include "vm/assembler.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 659 matching lines @@
 
 // Result of an invoke may be an unhandled exception, in which case we
 // rethrow it.
 static void CheckResultError(const Object& result) {
   if (result.IsError()) {
     Exceptions::PropagateError(Error::Cast(result));
   }
 }
 
 
+#if !defined(TARGET_ARCH_DBC)
 // Gets called from debug stub when code reaches a breakpoint
 // set on a runtime stub call.
 DEFINE_RUNTIME_ENTRY(BreakpointRuntimeHandler, 0) {
   if (!FLAG_support_debugger) {
     UNREACHABLE();
     return;
   }
   DartFrameIterator iterator;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   const Code& orig_stub = Code::Handle(
       isolate->debugger()->GetPatchedStubAddress(caller_frame->pc()));
   const Error& error = Error::Handle(isolate->debugger()->SignalBpReached());
   if (!error.IsNull()) {
     Exceptions::PropagateError(error);
     UNREACHABLE();
   }
   arguments.SetReturn(orig_stub);
 }
+#else
+// Gets called from the simulator when the breakpoint is reached.
+DEFINE_RUNTIME_ENTRY(BreakpointRuntimeHandler, 0) {
+  if (!FLAG_support_debugger) {
+    UNREACHABLE();
+    return;
+  }
+  const Error& error = Error::Handle(isolate->debugger()->SignalBpReached());
+  if (!error.IsNull()) {
+    Exceptions::PropagateError(error);
+    UNREACHABLE();
+  }
+}
+#endif  // !defined(TARGET_ARCH_DBC)
 
 
 DEFINE_RUNTIME_ENTRY(SingleStepHandler, 0) {
   if (!FLAG_support_debugger) {
     UNREACHABLE();
     return;
   }
   const Error& error =
       Error::Handle(isolate->debugger()->DebuggerStepCallback());
   if (!error.IsNull()) {
@@ skipping 307 matching lines @@
       // Switch to megamorphic call.
       const MegamorphicCache& cache = MegamorphicCache::Handle(zone,
           MegamorphicCacheTable::Lookup(isolate, name, descriptor));
       DartFrameIterator iterator;
       StackFrame* miss_function_frame = iterator.NextFrame();
       ASSERT(miss_function_frame->IsDartFrame());
       StackFrame* caller_frame = iterator.NextFrame();
       ASSERT(caller_frame->IsDartFrame());
       const Code& code = Code::Handle(zone, caller_frame->LookupDartCode());
       const Code& stub =
+#if !defined(TARGET_ARCH_DBC)
           Code::Handle(zone, StubCode::MegamorphicLookup_entry()->code());
+#else
+          Code::Handle();
+          UNREACHABLE();
+#endif
       CodePatcher::PatchSwitchableCallAt(caller_frame->pc(),
                                          code, ic_data, cache, stub);
     }
   } else {
     const MegamorphicCache& cache = MegamorphicCache::Cast(ic_data_or_cache);
     // Insert function found into cache and return it.
     cache.EnsureCapacity();
     const Smi& class_id = Smi::Handle(zone, Smi::New(cls.id()));
     cache.Insert(class_id, target_function);
   }
@@ skipping 168 matching lines @@
   const Object& result = Object::Handle(
       DartEntry::InvokeNoSuchMethod(receiver,
                                     original_function_name,
                                     orig_arguments,
                                     orig_arguments_desc));
   CheckResultError(result);
   arguments.SetReturn(result);
 }
 
 
+#if !defined(TARGET_ARCH_DBC)
 static bool CanOptimizeFunction(const Function& function, Thread* thread) {
   if (FLAG_support_debugger) {
     Isolate* isolate = thread->isolate();
     if (isolate->debugger()->IsStepping() ||
         isolate->debugger()->HasBreakpoint(function, thread->zone())) {
       // We cannot set breakpoints and single step in optimized code,
       // so do not optimize the function.
       function.set_usage_counter(0);
       return false;
     }
@@ skipping 41 matching lines @@
     // Huge methods (code size above --huge_method_cutoff_in_code_size) become
     // non-optimizable only after the code has been generated.
     if (FLAG_trace_failed_optimization_attempts) {
       THR_Print("Not optimizable: %s\n", function.ToFullyQualifiedCString());
     }
     function.set_usage_counter(INT_MIN);
     return false;
   }
   return true;
 }
+#endif
 
 
 DEFINE_RUNTIME_ENTRY(StackOverflow, 0) {
-#if defined(USING_SIMULATOR)
+#if defined(TARGET_ARCH_DBC)
+  uword stack_pos = Simulator::Current()->sp();
+#elif defined(USING_SIMULATOR)
   uword stack_pos = Simulator::Current()->get_register(SPREG);
 #else
   uword stack_pos = Isolate::GetCurrentStackPointer();
 #endif
   // Always clear the stack overflow flags.  They are meant for this
   // particular stack overflow runtime call and are not meant to
   // persist.
   uword stack_overflow_flags = isolate->GetAndClearStackOverflowFlags();
 
   // If an interrupt happens at the same time as a stack overflow, we
   // process the stack overflow now and leave the interrupt for next
   // time.
-  if (stack_pos < isolate->saved_stack_limit()) {
+  if (IsCalleeFrameOf(isolate->saved_stack_limit(), stack_pos)) {
     // Use the preallocated stack overflow exception to avoid calling
     // into dart code.
     const Instance& exception =
         Instance::Handle(isolate->object_store()->stack_overflow());
     Exceptions::Throw(thread, exception);
     UNREACHABLE();
   }
 
   // The following code is used to stress test deoptimization and
   // debugger stack tracing.
@@ skipping 59 matching lines @@
   }
 
   const Error& error = Error::Handle(isolate->HandleInterrupts());
   if (!error.IsNull()) {
     Exceptions::PropagateError(error);
     UNREACHABLE();
   }
 
   if ((stack_overflow_flags & Isolate::kOsrRequest) != 0) {
     ASSERT(FLAG_use_osr);
+#if !defined(TARGET_ARCH_DBC)
     DartFrameIterator iterator;
     StackFrame* frame = iterator.NextFrame();
     ASSERT(frame != NULL);
     const Code& code = Code::ZoneHandle(frame->LookupDartCode());
     ASSERT(!code.IsNull());
     const Function& function = Function::Handle(code.function());
     ASSERT(!function.IsNull());
     // Since the code is referenced from the frame and the ZoneHandle,
     // it cannot have been removed from the function.
     ASSERT(function.HasCode());
@@ skipping 32 matching lines @@
     if (optimized_code.raw() != original_code.raw()) {
       // The OSR code does not work for calling the function, so restore the
       // unoptimized code.  Patch the stack frame to return into the OSR
       // code.
       uword optimized_entry =
           Instructions::Handle(optimized_code.instructions()).EntryPoint();
       function.AttachCode(original_code);
       frame->set_pc(optimized_entry);
       frame->set_pc_marker(optimized_code.raw());
     }
+#endif
   }
 }
 
 
 DEFINE_RUNTIME_ENTRY(TraceICCall, 2) {
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(0));
   const Function& function = Function::CheckedHandle(arguments.ArgAt(1));
   DartFrameIterator iterator;
   StackFrame* frame = iterator.NextFrame();
   ASSERT(frame != NULL);
   OS::PrintErr("IC call @%#" Px ": ICData: %p cnt:%" Pd " nchecks: %" Pd
       " %s\n",
       frame->pc(),
       ic_data.raw(),
       function.usage_counter(),
       ic_data.NumberOfChecks(),
       function.ToFullyQualifiedCString());
 }
 
 
 // This is called from function that needs to be optimized.
 // The requesting function can be already optimized (reoptimization).
 // Returns the Code object where to continue execution.
 DEFINE_RUNTIME_ENTRY(OptimizeInvokedFunction, 1) {
-#if !defined(DART_PRECOMPILED_RUNTIME)
+#if !defined(DART_PRECOMPILED_RUNTIME) && !defined(TARGET_ARCH_DBC)
   const Function& function = Function::CheckedHandle(zone,
                                                      arguments.ArgAt(0));
   ASSERT(!function.IsNull());
   ASSERT(function.HasCode());
 
   if (CanOptimizeFunction(function, thread)) {
     if (FLAG_background_compilation) {
       Field& field = Field::Handle(zone, isolate->GetDeoptimizingBoxedField());
       while (!field.IsNull()) {
         if (FLAG_trace_optimization || FLAG_trace_field_guards) {
@@ skipping 433 matching lines @@
   const intptr_t elm_size = old_data.ElementSizeInBytes();
   const TypedData& new_data =
       TypedData::Handle(TypedData::New(cid, new_size, Heap::kOld));
   TypedData::Copy(new_data, 0, old_data, 0, old_size * elm_size);
   typed_data_cell.SetAt(0, new_data);
   arguments.SetReturn(new_data);
 }
 
 
 }  // namespace dart