Revised "Eliminate dependencies on assemblers and code stubs in precompiled runtime."

runtime/vm/debugger.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/debugger.h"
 
 #include "include/dart_api.h"
 
 #include "platform/address_sanitizer.h"
 
@@ skipping 653 matching lines @@
 bool ActivationFrame::IsDebuggable() const {
   return Debugger::IsDebuggable(function());
 }
 
 void ActivationFrame::PrintDescriptorsError(const char* message) {
   OS::PrintErr("Bad descriptors: %s\n", message);
   OS::PrintErr("function %s\n", function().ToQualifiedCString());
   OS::PrintErr("pc_ %" Px "\n", pc_);
   OS::PrintErr("deopt_id_ %" Px "\n", deopt_id_);
   OS::PrintErr("context_level_ %" Px "\n", context_level_);
+#if !defined(DART_PRECOMPILED_RUNTIME)
   DisassembleToStdout formatter;
   code().Disassemble(&formatter);
+#endif  // !defined(DART_PRECOMPILED_RUNTIME)
   PcDescriptors::Handle(code().pc_descriptors()).Print();
   StackFrameIterator frames(StackFrameIterator::kDontValidateFrames,
                             Thread::Current(),
                             StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* frame = frames.NextFrame();
   while (frame != NULL) {
     OS::PrintErr("%s\n", frame->ToCString());
     frame = frames.NextFrame();
   }
   OS::Abort();
@@ skipping 1086 matching lines @@
   if (FLAG_trace_debugger_stacktrace) {
     const Context& ctx = activation->GetSavedCurrentContext();
     OS::PrintErr("\tUsing saved context: %s\n", ctx.ToCString());
   }
   if (FLAG_trace_debugger_stacktrace) {
     OS::PrintErr("\tLine number: %" Pd "\n", activation->LineNumber());
   }
   return activation;
 }
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 RawArray* Debugger::DeoptimizeToArray(Thread* thread,
                                       StackFrame* frame,
                                       const Code& code) {
   ASSERT(code.is_optimized());
   Isolate* isolate = thread->isolate();
   // Create the DeoptContext for this deoptimization.
   DeoptContext* deopt_context =
       new DeoptContext(frame, code, DeoptContext::kDestIsAllocated, NULL, NULL,
                        true, false /* deoptimizing_code */);
   isolate->set_deopt_context(deopt_context);
 
   deopt_context->FillDestFrame();
   deopt_context->MaterializeDeferredObjects();
   const Array& dest_frame =
       Array::Handle(thread->zone(), deopt_context->DestFrameAsArray());
 
   isolate->set_deopt_context(NULL);
   delete deopt_context;
 
   return dest_frame.raw();
 }
+#endif  // !defined(DART_PRECOMPILED_RUNTIME)
 
 DebuggerStackTrace* Debugger::CollectStackTrace() {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
   StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames,
                               Thread::Current(),
                               StackFrameIterator::kNoCrossThreadIteration);
   Code& code = Code::Handle(zone);
@@ skipping 17 matching lines @@
 }
 
 void Debugger::AppendCodeFrames(Thread* thread,
                                 Isolate* isolate,
                                 Zone* zone,
                                 DebuggerStackTrace* stack_trace,
                                 StackFrame* frame,
                                 Code* code,
                                 Code* inlined_code,
                                 Array* deopt_frame) {
-  if (code->is_optimized() && !FLAG_precompiled_runtime) {
+#if !defined(DART_PRECOMPILED_RUNTIME)
+  if (code->is_optimized()) {
     // TODO(rmacnak): Use CodeSourceMap
     *deopt_frame = DeoptimizeToArray(thread, frame, *code);
     for (InlinedFunctionsIterator it(*code, frame->pc()); !it.Done();
          it.Advance()) {
       *inlined_code = it.code();
       if (FLAG_trace_debugger_stacktrace) {
         const Function& function = Function::Handle(zone, it.function());
         ASSERT(!function.IsNull());
         OS::PrintErr("CollectStackTrace: visiting inlined function: %s\n",
                      function.ToFullyQualifiedCString());
       }
       intptr_t deopt_frame_offset = it.GetDeoptFpOffset();
       stack_trace->AddActivation(CollectDartFrame(isolate, it.pc(), frame,
                                                   *inlined_code, *deopt_frame,
                                                   deopt_frame_offset));
     }
-  } else {
-    stack_trace->AddActivation(CollectDartFrame(
-        isolate, frame->pc(), frame, *code, Object::null_array(), 0));
+    return;
   }
+#endif  // !defined(DART_PRECOMPILED_RUNTIME)
+  stack_trace->AddActivation(CollectDartFrame(isolate, frame->pc(), frame,
+                                              *code, Object::null_array(), 0));
 }
 
 DebuggerStackTrace* Debugger::CollectAsyncCausalStackTrace() {
   if (!FLAG_causal_async_stacks) {
     return NULL;
   }
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
@@ skipping 68 matching lines @@
       }
     }
     // Follow the link.
     async_stack_trace = async_stack_trace.async_link();
   }
 
   return stack_trace;
 }
 
 DebuggerStackTrace* Debugger::CollectAwaiterReturnStackTrace() {
+#if defined(DART_PRECOMPILED_RUNTIME)
+  // Causal async stacks are not supported in the AOT runtime.
+  ASSERT(!FLAG_async_debugger);
+  return NULL;
+#else
   if (!FLAG_async_debugger) {
     return NULL;
   }
-  // Causal async stacks are not supported in the AOT runtime.
-  ASSERT(!FLAG_precompiled_runtime);
 
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
 
   StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames,
                               Thread::Current(),
                               StackFrameIterator::kNoCrossThreadIteration);
 
@@ skipping 118 matching lines @@
         } else {
           stack_trace->AddAsyncCausalFrame(pc, code);
         }
       }
     }
     // Follow the link.
     async_stack_trace = async_stack_trace.async_link();
   }
 
   return stack_trace;
+#endif  // defined(DART_PRECOMPILED_RUNTIME)
 }
 
 ActivationFrame* Debugger::TopDartFrame() const {
   StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames,
                               Thread::Current(),
                               StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* frame = iterator.NextFrame();
   while ((frame != NULL) && !frame->IsDartFrame()) {
     frame = iterator.NextFrame();
   }
@@ skipping 2258 matching lines @@
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart