asiva@google.com
f4fe42c280
which have different implementations of 'operator=' and 'operator^='. In the case of FINAL_OBJECT_IMPLEMENTATION we do not do the vtable setting in these methods (Note the |= operator functionality is now subsumed into the new implementation of "operator^=") Review URL: https://codereview.chromium.org//12052033 git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@17491 260f80e4-7a28-3924-810f-c04153c831b5
1738 lines
54 KiB
C++
1738 lines
54 KiB
C++
// 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 "vm/code_generator.h"
|
|
#include "vm/code_patcher.h"
|
|
#include "vm/compiler.h"
|
|
#include "vm/dart_entry.h"
|
|
#include "vm/flags.h"
|
|
#include "vm/globals.h"
|
|
#include "vm/longjump.h"
|
|
#include "vm/object.h"
|
|
#include "vm/object_store.h"
|
|
#include "vm/os.h"
|
|
#include "vm/port.h"
|
|
#include "vm/stack_frame.h"
|
|
#include "vm/stub_code.h"
|
|
#include "vm/symbols.h"
|
|
#include "vm/visitor.h"
|
|
|
|
|
|
namespace dart {
|
|
|
|
DEFINE_FLAG(bool, verbose_debug, false, "Verbose debugger messages");
|
|
|
|
|
|
static void DefaultBreakpointHandler(Dart_Port isolate_id,
|
|
SourceBreakpoint* bpt,
|
|
DebuggerStackTrace* stack) {
|
|
String& var_name = String::Handle();
|
|
Instance& value = Instance::Handle();
|
|
for (intptr_t i = 0; i < stack->Length(); i++) {
|
|
ActivationFrame* frame = stack->ActivationFrameAt(i);
|
|
OS::Print(" %"Pd". %s\n",
|
|
i + 1, frame->ToCString());
|
|
intptr_t num_locals = frame->NumLocalVariables();
|
|
for (intptr_t i = 0; i < num_locals; i++) {
|
|
intptr_t token_pos, end_pos;
|
|
frame->VariableAt(i, &var_name, &token_pos, &end_pos, &value);
|
|
OS::Print(" var %s (pos %"Pd") = %s\n",
|
|
var_name.ToCString(), token_pos, value.ToCString());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
BreakpointHandler* Debugger::bp_handler_ = DefaultBreakpointHandler;
|
|
Debugger::EventHandler* Debugger::event_handler_ = NULL;
|
|
|
|
|
|
class RemoteObjectCache : public ZoneAllocated {
|
|
public:
|
|
explicit RemoteObjectCache(intptr_t initial_size);
|
|
intptr_t AddObject(const Object& obj);
|
|
RawObject* GetObj(intptr_t obj_id) const;
|
|
bool IsValidId(intptr_t obj_id) const {
|
|
return obj_id < objs_->Length();
|
|
}
|
|
|
|
private:
|
|
GrowableObjectArray* objs_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(RemoteObjectCache);
|
|
};
|
|
|
|
|
|
SourceBreakpoint::SourceBreakpoint(intptr_t id,
|
|
const Function& func,
|
|
intptr_t token_pos)
|
|
: id_(id),
|
|
function_(func.raw()),
|
|
token_pos_(token_pos),
|
|
line_number_(-1),
|
|
is_enabled_(false),
|
|
next_(NULL) {
|
|
ASSERT(!func.IsNull());
|
|
ASSERT((func.token_pos() <= token_pos_) &&
|
|
(token_pos_ < func.end_token_pos()));
|
|
}
|
|
|
|
|
|
void SourceBreakpoint::Enable() {
|
|
is_enabled_ = true;
|
|
Isolate::Current()->debugger()->SyncBreakpoint(this);
|
|
}
|
|
|
|
|
|
void SourceBreakpoint::Disable() {
|
|
is_enabled_ = false;
|
|
Isolate::Current()->debugger()->SyncBreakpoint(this);
|
|
}
|
|
|
|
|
|
RawScript* SourceBreakpoint::SourceCode() {
|
|
const Function& func = Function::Handle(function_);
|
|
return func.script();
|
|
}
|
|
|
|
|
|
RawString* SourceBreakpoint::SourceUrl() {
|
|
const Script& script = Script::Handle(SourceCode());
|
|
return script.url();
|
|
}
|
|
|
|
|
|
intptr_t SourceBreakpoint::LineNumber() {
|
|
// Compute line number lazily since it causes scanning of the script.
|
|
if (line_number_ < 0) {
|
|
const Script& script = Script::Handle(SourceCode());
|
|
intptr_t ignore_column;
|
|
script.GetTokenLocation(token_pos_, &line_number_, &ignore_column);
|
|
}
|
|
return line_number_;
|
|
}
|
|
|
|
|
|
void SourceBreakpoint::set_function(const Function& func) {
|
|
function_ = func.raw();
|
|
}
|
|
|
|
|
|
void SourceBreakpoint::VisitObjectPointers(ObjectPointerVisitor* visitor) {
|
|
visitor->VisitPointer(reinterpret_cast<RawObject**>(&function_));
|
|
}
|
|
|
|
|
|
|
|
void CodeBreakpoint::VisitObjectPointers(ObjectPointerVisitor* visitor) {
|
|
visitor->VisitPointer(reinterpret_cast<RawObject**>(&function_));
|
|
}
|
|
|
|
|
|
ActivationFrame::ActivationFrame(uword pc, uword fp, uword sp,
|
|
const Context& ctx)
|
|
: pc_(pc), fp_(fp), sp_(sp),
|
|
ctx_(Context::ZoneHandle(ctx.raw())),
|
|
function_(Function::ZoneHandle()),
|
|
code_(Code::ZoneHandle()),
|
|
token_pos_(-1),
|
|
pc_desc_index_(-1),
|
|
line_number_(-1),
|
|
context_level_(-1),
|
|
vars_initialized_(false),
|
|
var_descriptors_(LocalVarDescriptors::ZoneHandle()),
|
|
desc_indices_(8),
|
|
pc_desc_(PcDescriptors::ZoneHandle()) {
|
|
}
|
|
|
|
|
|
const Code& ActivationFrame::DartCode() {
|
|
if (code_.IsNull()) {
|
|
Isolate* isolate = Isolate::Current();
|
|
ASSERT(isolate != NULL);
|
|
code_ = Code::LookupCode(pc_);
|
|
}
|
|
return code_;
|
|
}
|
|
|
|
|
|
const Function& ActivationFrame::DartFunction() {
|
|
if (function_.IsNull()) {
|
|
function_ = DartCode().function();
|
|
}
|
|
return function_;
|
|
}
|
|
|
|
|
|
void Debugger::SignalIsolateEvent(EventType type) {
|
|
if (event_handler_ != NULL) {
|
|
Debugger* debugger = Isolate::Current()->debugger();
|
|
ASSERT(debugger != NULL);
|
|
DebuggerEvent event;
|
|
event.type = type;
|
|
event.isolate_id = debugger->GetIsolateId();
|
|
ASSERT(event.isolate_id != ILLEGAL_ISOLATE_ID);
|
|
if (type == kIsolateInterrupted) {
|
|
DebuggerStackTrace* stack_trace = debugger->CollectStackTrace();
|
|
ASSERT(stack_trace->Length() > 0);
|
|
ASSERT(debugger->stack_trace_ == NULL);
|
|
ASSERT(debugger->obj_cache_ == NULL);
|
|
debugger->obj_cache_ = new RemoteObjectCache(64);
|
|
debugger->stack_trace_ = stack_trace;
|
|
(*event_handler_)(&event);
|
|
debugger->stack_trace_ = NULL;
|
|
debugger->obj_cache_ = NULL; // Remote object cache is zone allocated.
|
|
// TODO(asiva): Need some work here to be able to single step after
|
|
// an interrupt.
|
|
} else {
|
|
(*event_handler_)(&event);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
const char* Debugger::QualifiedFunctionName(const Function& func) {
|
|
const String& func_name = String::Handle(func.name());
|
|
Class& func_class = Class::Handle(func.Owner());
|
|
String& class_name = String::Handle(func_class.Name());
|
|
|
|
const char* kFormat = "%s%s%s";
|
|
intptr_t len = OS::SNPrint(NULL, 0, kFormat,
|
|
func_class.IsTopLevel() ? "" : class_name.ToCString(),
|
|
func_class.IsTopLevel() ? "" : ".",
|
|
func_name.ToCString());
|
|
len++; // String terminator.
|
|
char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
|
|
OS::SNPrint(chars, len, kFormat,
|
|
func_class.IsTopLevel() ? "" : class_name.ToCString(),
|
|
func_class.IsTopLevel() ? "" : ".",
|
|
func_name.ToCString());
|
|
return chars;
|
|
}
|
|
|
|
|
|
bool Debugger::HasBreakpoint(const Function& func) {
|
|
if (!func.HasCode()) {
|
|
// If the function is not compiled yet, just check whether there
|
|
// is a user-defined latent breakpoint.
|
|
SourceBreakpoint* sbpt = src_breakpoints_;
|
|
while (sbpt != NULL) {
|
|
if (func.raw() == sbpt->function()) {
|
|
return true;
|
|
}
|
|
sbpt = sbpt->next_;
|
|
}
|
|
return false;
|
|
}
|
|
CodeBreakpoint* cbpt = code_breakpoints_;
|
|
while (cbpt != NULL) {
|
|
if (func.raw() == cbpt->function()) {
|
|
return true;
|
|
}
|
|
cbpt = cbpt->next_;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
RawString* ActivationFrame::QualifiedFunctionName() {
|
|
const Function& func = DartFunction();
|
|
return String::New(Debugger::QualifiedFunctionName(func));
|
|
}
|
|
|
|
|
|
RawString* ActivationFrame::SourceUrl() {
|
|
const Script& script = Script::Handle(SourceScript());
|
|
return script.url();
|
|
}
|
|
|
|
|
|
RawScript* ActivationFrame::SourceScript() {
|
|
const Function& func = DartFunction();
|
|
return func.script();
|
|
}
|
|
|
|
|
|
RawLibrary* ActivationFrame::Library() {
|
|
const Function& func = DartFunction();
|
|
const Class& cls = Class::Handle(func.Owner());
|
|
return cls.library();
|
|
}
|
|
|
|
|
|
void ActivationFrame::GetPcDescriptors() {
|
|
if (pc_desc_.IsNull()) {
|
|
const Code& code = DartCode();
|
|
ASSERT(!code.IsNull());
|
|
pc_desc_ = code.pc_descriptors();
|
|
ASSERT(!pc_desc_.IsNull());
|
|
}
|
|
}
|
|
|
|
|
|
// Compute token_pos_ and pc_desc_index_.
|
|
intptr_t ActivationFrame::TokenPos() {
|
|
if (token_pos_ < 0) {
|
|
GetPcDescriptors();
|
|
for (int i = 0; i < pc_desc_.Length(); i++) {
|
|
if (pc_desc_.PC(i) == pc_) {
|
|
pc_desc_index_ = i;
|
|
token_pos_ = pc_desc_.TokenPos(i);
|
|
break;
|
|
}
|
|
}
|
|
ASSERT(token_pos_ >= 0);
|
|
}
|
|
return token_pos_;
|
|
}
|
|
|
|
|
|
intptr_t ActivationFrame::PcDescIndex() {
|
|
if (pc_desc_index_ < 0) {
|
|
TokenPos();
|
|
ASSERT(pc_desc_index_ >= 0);
|
|
}
|
|
return pc_desc_index_;
|
|
}
|
|
|
|
|
|
intptr_t ActivationFrame::TryIndex() {
|
|
intptr_t desc_index = PcDescIndex();
|
|
return pc_desc_.TryIndex(desc_index);
|
|
}
|
|
|
|
|
|
intptr_t ActivationFrame::LineNumber() {
|
|
// Compute line number lazily since it causes scanning of the script.
|
|
if (line_number_ < 0) {
|
|
const Script& script = Script::Handle(SourceScript());
|
|
intptr_t ignore_column;
|
|
script.GetTokenLocation(TokenPos(), &line_number_, &ignore_column);
|
|
}
|
|
return line_number_;
|
|
}
|
|
|
|
|
|
void ActivationFrame::GetVarDescriptors() {
|
|
if (var_descriptors_.IsNull()) {
|
|
const Code& code = DartCode();
|
|
var_descriptors_ = code.var_descriptors();
|
|
ASSERT(!var_descriptors_.IsNull());
|
|
}
|
|
}
|
|
|
|
|
|
// Calculate the context level at the current token index of the frame.
|
|
intptr_t ActivationFrame::ContextLevel() {
|
|
if (context_level_ < 0) {
|
|
context_level_ = 0;
|
|
intptr_t pc_desc_idx = PcDescIndex();
|
|
ASSERT(!pc_desc_.IsNull());
|
|
if (pc_desc_.DescriptorKind(pc_desc_idx) == PcDescriptors::kReturn) {
|
|
// Special case: the context chain has already been deallocated.
|
|
// The context level is 0.
|
|
return context_level_;
|
|
}
|
|
intptr_t innermost_begin_pos = 0;
|
|
intptr_t activation_token_pos = TokenPos();
|
|
GetVarDescriptors();
|
|
intptr_t var_desc_len = var_descriptors_.Length();
|
|
for (int cur_idx = 0; cur_idx < var_desc_len; cur_idx++) {
|
|
RawLocalVarDescriptors::VarInfo var_info;
|
|
var_descriptors_.GetInfo(cur_idx, &var_info);
|
|
if ((var_info.kind == RawLocalVarDescriptors::kContextLevel) &&
|
|
(var_info.begin_pos <= activation_token_pos) &&
|
|
(activation_token_pos < var_info.end_pos)) {
|
|
// This var_descriptors_ entry is a context scope which is in scope
|
|
// of the current token position. Now check whether it is shadowing
|
|
// the previous context scope.
|
|
if (innermost_begin_pos < var_info.begin_pos) {
|
|
innermost_begin_pos = var_info.begin_pos;
|
|
context_level_ = var_info.index;
|
|
}
|
|
}
|
|
}
|
|
ASSERT(context_level_ >= 0);
|
|
}
|
|
return context_level_;
|
|
}
|
|
|
|
|
|
RawContext* ActivationFrame::CallerContext() {
|
|
GetVarDescriptors();
|
|
intptr_t var_desc_len = var_descriptors_.Length();
|
|
for (int i = 0; i < var_desc_len; i++) {
|
|
RawLocalVarDescriptors::VarInfo var_info;
|
|
var_descriptors_.GetInfo(i, &var_info);
|
|
if (var_info.kind == RawLocalVarDescriptors::kContextChain) {
|
|
return reinterpret_cast<RawContext*>(GetLocalVarValue(var_info.index));
|
|
}
|
|
}
|
|
// Caller uses same context chain.
|
|
return ctx_.raw();
|
|
}
|
|
|
|
|
|
ActivationFrame* DebuggerStackTrace::GetHandlerFrame(
|
|
const Instance& exc_obj) const {
|
|
ExceptionHandlers& handlers = ExceptionHandlers::Handle();
|
|
Array& handled_types = Array::Handle();
|
|
AbstractType& type = Type::Handle();
|
|
const TypeArguments& no_instantiator = TypeArguments::Handle();
|
|
for (int frame_index = 0; frame_index < Length(); frame_index++) {
|
|
ActivationFrame* frame = trace_[frame_index];
|
|
intptr_t try_index = frame->TryIndex();
|
|
if (try_index < 0) continue;
|
|
const Code& code = frame->DartCode();
|
|
handlers = code.exception_handlers();
|
|
ASSERT(!handlers.IsNull());
|
|
intptr_t num_handlers_checked = 0;
|
|
while (try_index >= 0) {
|
|
// Detect circles in the exception handler data.
|
|
num_handlers_checked++;
|
|
ASSERT(num_handlers_checked <= handlers.Length());
|
|
handled_types = handlers.GetHandledTypes(try_index);
|
|
const intptr_t num_types = handled_types.Length();
|
|
for (int k = 0; k < num_types; k++) {
|
|
type ^= handled_types.At(k);
|
|
ASSERT(!type.IsNull());
|
|
// Uninstantiated types are not added to ExceptionHandlers data.
|
|
ASSERT(type.IsInstantiated());
|
|
if (type.IsDynamicType()) return frame;
|
|
if (type.IsMalformed()) continue;
|
|
if (exc_obj.IsInstanceOf(type, no_instantiator, NULL)) {
|
|
return frame;
|
|
}
|
|
}
|
|
try_index = handlers.OuterTryIndex(try_index);
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void ActivationFrame::GetDescIndices() {
|
|
if (vars_initialized_) {
|
|
return;
|
|
}
|
|
GetVarDescriptors();
|
|
|
|
// We don't trust variable descriptors in optimized code.
|
|
// Rather than potentially displaying incorrect values, we
|
|
// pretend that there are no variables in the frame.
|
|
// We should be more clever about this in the future.
|
|
if (DartCode().is_optimized()) {
|
|
vars_initialized_ = true;
|
|
return;
|
|
}
|
|
|
|
GrowableArray<String*> var_names(8);
|
|
intptr_t activation_token_pos = TokenPos();
|
|
intptr_t var_desc_len = var_descriptors_.Length();
|
|
for (int cur_idx = 0; cur_idx < var_desc_len; cur_idx++) {
|
|
ASSERT(var_names.length() == desc_indices_.length());
|
|
RawLocalVarDescriptors::VarInfo var_info;
|
|
var_descriptors_.GetInfo(cur_idx, &var_info);
|
|
if ((var_info.kind != RawLocalVarDescriptors::kStackVar) &&
|
|
(var_info.kind != RawLocalVarDescriptors::kContextVar)) {
|
|
continue;
|
|
}
|
|
if ((var_info.begin_pos <= activation_token_pos) &&
|
|
(activation_token_pos <= var_info.end_pos)) {
|
|
if ((var_info.kind == RawLocalVarDescriptors::kContextVar) &&
|
|
(ContextLevel() < var_info.scope_id)) {
|
|
// The variable is textually in scope but the context level
|
|
// at the activation frame's PC is lower than the context
|
|
// level of the variable. The context containing the variable
|
|
// has already been removed from the chain. This can happen when we
|
|
// break at a return statement, since the contexts get discarded
|
|
// before the debugger gets called.
|
|
continue;
|
|
}
|
|
// The current variable is textually in scope. Now check whether
|
|
// there is another local variable with the same name that shadows
|
|
// or is shadowed by this variable.
|
|
String& var_name = String::Handle(var_descriptors_.GetName(cur_idx));
|
|
intptr_t indices_len = desc_indices_.length();
|
|
bool name_match_found = false;
|
|
for (int i = 0; i < indices_len; i++) {
|
|
if (var_name.Equals(*var_names[i])) {
|
|
// Found two local variables with the same name. Now determine
|
|
// which one is shadowed.
|
|
name_match_found = true;
|
|
RawLocalVarDescriptors::VarInfo i_var_info;
|
|
var_descriptors_.GetInfo(desc_indices_[i], &i_var_info);
|
|
if (i_var_info.begin_pos < var_info.begin_pos) {
|
|
// The variable we found earlier is in an outer scope
|
|
// and is shadowed by the current variable. Replace the
|
|
// descriptor index of the previously found variable
|
|
// with the descriptor index of the current variable.
|
|
desc_indices_[i] = cur_idx;
|
|
} else {
|
|
// The variable we found earlier is in an inner scope
|
|
// and shadows the current variable. Skip the current
|
|
// variable. (Nothing to do.)
|
|
}
|
|
break; // Stop looking for name matches.
|
|
}
|
|
}
|
|
if (!name_match_found) {
|
|
// No duplicate name found. Add the current descriptor index to the
|
|
// list of visible variables.
|
|
desc_indices_.Add(cur_idx);
|
|
var_names.Add(&var_name);
|
|
}
|
|
}
|
|
}
|
|
vars_initialized_ = true;
|
|
}
|
|
|
|
|
|
intptr_t ActivationFrame::NumLocalVariables() {
|
|
GetDescIndices();
|
|
return desc_indices_.length();
|
|
}
|
|
|
|
|
|
void ActivationFrame::VariableAt(intptr_t i,
|
|
String* name,
|
|
intptr_t* token_pos,
|
|
intptr_t* end_pos,
|
|
Instance* value) {
|
|
GetDescIndices();
|
|
ASSERT(i < desc_indices_.length());
|
|
intptr_t desc_index = desc_indices_[i];
|
|
ASSERT(name != NULL);
|
|
*name ^= var_descriptors_.GetName(desc_index);
|
|
RawLocalVarDescriptors::VarInfo var_info;
|
|
var_descriptors_.GetInfo(desc_index, &var_info);
|
|
ASSERT(token_pos != NULL);
|
|
*token_pos = var_info.begin_pos;
|
|
ASSERT(end_pos != NULL);
|
|
*end_pos = var_info.end_pos;
|
|
ASSERT(value != NULL);
|
|
if (var_info.kind == RawLocalVarDescriptors::kStackVar) {
|
|
*value = GetLocalVarValue(var_info.index);
|
|
} else {
|
|
ASSERT(var_info.kind == RawLocalVarDescriptors::kContextVar);
|
|
ASSERT(!ctx_.IsNull());
|
|
// The context level at the PC/token index of this activation frame.
|
|
intptr_t frame_ctx_level = ContextLevel();
|
|
// The context level of the variable.
|
|
intptr_t var_ctx_level = var_info.scope_id;
|
|
intptr_t level_diff = frame_ctx_level - var_ctx_level;
|
|
intptr_t ctx_slot = var_info.index;
|
|
if (level_diff == 0) {
|
|
*value = ctx_.At(ctx_slot);
|
|
} else {
|
|
ASSERT(level_diff > 0);
|
|
Context& ctx = Context::Handle(ctx_.raw());
|
|
while (level_diff > 0) {
|
|
ASSERT(!ctx.IsNull());
|
|
level_diff--;
|
|
ctx = ctx.parent();
|
|
}
|
|
ASSERT(!ctx.IsNull());
|
|
*value = ctx.At(ctx_slot);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
RawArray* ActivationFrame::GetLocalVariables() {
|
|
GetDescIndices();
|
|
intptr_t num_variables = desc_indices_.length();
|
|
String& var_name = String::Handle();
|
|
Instance& value = Instance::Handle();
|
|
const Array& list = Array::Handle(Array::New(2 * num_variables));
|
|
for (int i = 0; i < num_variables; i++) {
|
|
intptr_t ignore;
|
|
VariableAt(i, &var_name, &ignore, &ignore, &value);
|
|
list.SetAt(2 * i, var_name);
|
|
list.SetAt((2 * i) + 1, value);
|
|
}
|
|
return list.raw();
|
|
}
|
|
|
|
|
|
const char* ActivationFrame::ToCString() {
|
|
const char* kFormat = "Function: '%s' url: '%s' line: %d";
|
|
|
|
const Function& func = DartFunction();
|
|
const String& url = String::Handle(SourceUrl());
|
|
intptr_t line = LineNumber();
|
|
const char* func_name = Debugger::QualifiedFunctionName(func);
|
|
|
|
intptr_t len =
|
|
OS::SNPrint(NULL, 0, kFormat, func_name, url.ToCString(), line);
|
|
len++; // String terminator.
|
|
char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
|
|
OS::SNPrint(chars, len, kFormat, func_name, url.ToCString(), line);
|
|
return chars;
|
|
}
|
|
|
|
|
|
void DebuggerStackTrace::AddActivation(ActivationFrame* frame) {
|
|
trace_.Add(frame);
|
|
}
|
|
|
|
|
|
CodeBreakpoint::CodeBreakpoint(const Function& func, intptr_t pc_desc_index)
|
|
: function_(func.raw()),
|
|
pc_desc_index_(pc_desc_index),
|
|
pc_(0),
|
|
line_number_(-1),
|
|
is_enabled_(false),
|
|
src_bpt_(NULL),
|
|
next_(NULL) {
|
|
ASSERT(!func.HasOptimizedCode());
|
|
Code& code = Code::Handle(func.unoptimized_code());
|
|
ASSERT(!code.IsNull()); // Function must be compiled.
|
|
PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
|
|
ASSERT(pc_desc_index < desc.Length());
|
|
token_pos_ = desc.TokenPos(pc_desc_index);
|
|
ASSERT(token_pos_ >= 0);
|
|
pc_ = desc.PC(pc_desc_index);
|
|
ASSERT(pc_ != 0);
|
|
breakpoint_kind_ = desc.DescriptorKind(pc_desc_index);
|
|
ASSERT((breakpoint_kind_ == PcDescriptors::kIcCall) ||
|
|
(breakpoint_kind_ == PcDescriptors::kFuncCall) ||
|
|
(breakpoint_kind_ == PcDescriptors::kReturn));
|
|
}
|
|
|
|
|
|
CodeBreakpoint::~CodeBreakpoint() {
|
|
// Make sure we don't leave patched code behind.
|
|
ASSERT(!IsEnabled());
|
|
// Poison the data so we catch use after free errors.
|
|
#ifdef DEBUG
|
|
function_ = Function::null();
|
|
pc_ = 0ul;
|
|
src_bpt_ = NULL;
|
|
next_ = NULL;
|
|
breakpoint_kind_ = PcDescriptors::kOther;
|
|
#endif
|
|
}
|
|
|
|
|
|
RawScript* CodeBreakpoint::SourceCode() {
|
|
const Function& func = Function::Handle(function_);
|
|
return func.script();
|
|
}
|
|
|
|
|
|
RawString* CodeBreakpoint::SourceUrl() {
|
|
const Script& script = Script::Handle(SourceCode());
|
|
return script.url();
|
|
}
|
|
|
|
|
|
intptr_t CodeBreakpoint::LineNumber() {
|
|
// Compute line number lazily since it causes scanning of the script.
|
|
if (line_number_ < 0) {
|
|
const Script& script = Script::Handle(SourceCode());
|
|
intptr_t ignore_column;
|
|
script.GetTokenLocation(token_pos_, &line_number_, &ignore_column);
|
|
}
|
|
return line_number_;
|
|
}
|
|
|
|
|
|
void CodeBreakpoint::PatchCode() {
|
|
ASSERT(!is_enabled_);
|
|
switch (breakpoint_kind_) {
|
|
case PcDescriptors::kIcCall: {
|
|
saved_bytes_.target_address_ =
|
|
CodePatcher::GetInstanceCallAt(pc_, NULL, NULL);
|
|
CodePatcher::PatchInstanceCallAt(pc_,
|
|
StubCode::BreakpointDynamicEntryPoint());
|
|
break;
|
|
}
|
|
case PcDescriptors::kFuncCall: {
|
|
saved_bytes_.target_address_ = CodePatcher::GetStaticCallTargetAt(pc_);
|
|
CodePatcher::PatchStaticCallAt(pc_,
|
|
StubCode::BreakpointStaticEntryPoint());
|
|
break;
|
|
}
|
|
case PcDescriptors::kReturn:
|
|
PatchFunctionReturn();
|
|
break;
|
|
default:
|
|
UNREACHABLE();
|
|
}
|
|
is_enabled_ = true;
|
|
}
|
|
|
|
|
|
void CodeBreakpoint::RestoreCode() {
|
|
ASSERT(is_enabled_);
|
|
switch (breakpoint_kind_) {
|
|
case PcDescriptors::kIcCall:
|
|
CodePatcher::PatchInstanceCallAt(pc_, saved_bytes_.target_address_);
|
|
break;
|
|
case PcDescriptors::kFuncCall:
|
|
CodePatcher::PatchStaticCallAt(pc_, saved_bytes_.target_address_);
|
|
break;
|
|
case PcDescriptors::kReturn:
|
|
RestoreFunctionReturn();
|
|
break;
|
|
default:
|
|
UNREACHABLE();
|
|
}
|
|
is_enabled_ = false;
|
|
}
|
|
|
|
|
|
void CodeBreakpoint::Enable() {
|
|
if (!is_enabled_) {
|
|
PatchCode();
|
|
}
|
|
ASSERT(is_enabled_);
|
|
}
|
|
|
|
|
|
void CodeBreakpoint::Disable() {
|
|
if (is_enabled_) {
|
|
RestoreCode();
|
|
}
|
|
ASSERT(!is_enabled_);
|
|
}
|
|
|
|
|
|
RemoteObjectCache::RemoteObjectCache(intptr_t initial_size) {
|
|
objs_ = &GrowableObjectArray::ZoneHandle(
|
|
GrowableObjectArray::New(initial_size));
|
|
}
|
|
|
|
|
|
intptr_t RemoteObjectCache::AddObject(const Object& obj) {
|
|
intptr_t len = objs_->Length();
|
|
for (int i = 0; i < len; i++) {
|
|
if (objs_->At(i) == obj.raw()) {
|
|
return i;
|
|
}
|
|
}
|
|
objs_->Add(obj);
|
|
return len;
|
|
}
|
|
|
|
|
|
RawObject* RemoteObjectCache::GetObj(intptr_t obj_id) const {
|
|
ASSERT(IsValidId(obj_id));
|
|
return objs_->At(obj_id);
|
|
}
|
|
|
|
|
|
Debugger::Debugger()
|
|
: isolate_(NULL),
|
|
isolate_id_(ILLEGAL_ISOLATE_ID),
|
|
initialized_(false),
|
|
next_id_(1),
|
|
stack_trace_(NULL),
|
|
obj_cache_(NULL),
|
|
src_breakpoints_(NULL),
|
|
code_breakpoints_(NULL),
|
|
resume_action_(kContinue),
|
|
last_bpt_line_(-1),
|
|
ignore_breakpoints_(false),
|
|
exc_pause_info_(kNoPauseOnExceptions) {
|
|
}
|
|
|
|
|
|
Debugger::~Debugger() {
|
|
PortMap::ClosePort(isolate_id_);
|
|
isolate_id_ = ILLEGAL_ISOLATE_ID;
|
|
ASSERT(src_breakpoints_ == NULL);
|
|
ASSERT(code_breakpoints_ == NULL);
|
|
ASSERT(stack_trace_ == NULL);
|
|
ASSERT(obj_cache_ == NULL);
|
|
}
|
|
|
|
|
|
void Debugger::Shutdown() {
|
|
while (src_breakpoints_ != NULL) {
|
|
SourceBreakpoint* bpt = src_breakpoints_;
|
|
src_breakpoints_ = src_breakpoints_->next();
|
|
delete bpt;
|
|
}
|
|
while (code_breakpoints_ != NULL) {
|
|
CodeBreakpoint* bpt = code_breakpoints_;
|
|
code_breakpoints_ = code_breakpoints_->next();
|
|
bpt->Disable();
|
|
delete bpt;
|
|
}
|
|
// Signal isolate shutdown event.
|
|
SignalIsolateEvent(Debugger::kIsolateShutdown);
|
|
}
|
|
|
|
|
|
static RawFunction* ResolveLibraryFunction(
|
|
const Library& library,
|
|
const String& fname) {
|
|
ASSERT(!library.IsNull());
|
|
const Object& object = Object::Handle(library.LookupObject(fname));
|
|
if (!object.IsNull() && object.IsFunction()) {
|
|
return Function::Cast(object).raw();
|
|
}
|
|
return Function::null();
|
|
}
|
|
|
|
|
|
RawFunction* Debugger::ResolveFunction(const Library& library,
|
|
const String& class_name,
|
|
const String& function_name) {
|
|
ASSERT(!library.IsNull());
|
|
ASSERT(!class_name.IsNull());
|
|
ASSERT(!function_name.IsNull());
|
|
if (class_name.Length() == 0) {
|
|
return ResolveLibraryFunction(library, function_name);
|
|
}
|
|
const Class& cls = Class::Handle(library.LookupClass(class_name));
|
|
Function& function = Function::Handle();
|
|
if (!cls.IsNull()) {
|
|
function = cls.LookupStaticFunction(function_name);
|
|
if (function.IsNull()) {
|
|
function = cls.LookupDynamicFunction(function_name);
|
|
}
|
|
}
|
|
return function.raw();
|
|
}
|
|
|
|
|
|
// Deoptimize all functions in the isolate.
|
|
// TODO(hausner): Actually we only need to deoptimize those functions
|
|
// that inline the function that contains the newly created breakpoint.
|
|
// We currently don't have this info so we deoptimize all functions.
|
|
void Debugger::DeoptimizeWorld() {
|
|
// Deoptimize all functions in stack activation frames.
|
|
DeoptimizeAll();
|
|
// Iterate over all classes, deoptimize functions.
|
|
// TODO(hausner): Could possibly be combined with RemoveOptimizedCode()
|
|
const ClassTable& class_table = *isolate_->class_table();
|
|
Class& cls = Class::Handle();
|
|
Array& functions = Array::Handle();
|
|
Function& function = Function::Handle();
|
|
intptr_t num_classes = class_table.NumCids();
|
|
for (intptr_t i = 1; i < num_classes; i++) {
|
|
if (class_table.HasValidClassAt(i)) {
|
|
cls = class_table.At(i);
|
|
functions = cls.functions();
|
|
intptr_t num_functions = functions.IsNull() ? 0 : functions.Length();
|
|
for (intptr_t f = 0; f < num_functions; f++) {
|
|
function ^= functions.At(f);
|
|
ASSERT(!function.IsNull());
|
|
if (function.HasOptimizedCode()) {
|
|
function.SwitchToUnoptimizedCode();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Debugger::InstrumentForStepping(const Function& target_function) {
|
|
if (!target_function.HasCode()) {
|
|
Compiler::CompileFunction(target_function);
|
|
// If there were any errors, ignore them silently and return without
|
|
// adding breakpoints to target.
|
|
if (!target_function.HasCode()) {
|
|
return;
|
|
}
|
|
}
|
|
DeoptimizeWorld();
|
|
ASSERT(!target_function.HasOptimizedCode());
|
|
Code& code = Code::Handle(target_function.unoptimized_code());
|
|
ASSERT(!code.IsNull());
|
|
PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
|
|
for (int i = 0; i < desc.Length(); i++) {
|
|
CodeBreakpoint* bpt = GetCodeBreakpoint(desc.PC(i));
|
|
if (bpt != NULL) {
|
|
// There is already a breakpoint for this address. Make sure
|
|
// it is enabled.
|
|
bpt->Enable();
|
|
continue;
|
|
}
|
|
PcDescriptors::Kind kind = desc.DescriptorKind(i);
|
|
if ((kind == PcDescriptors::kIcCall) ||
|
|
(kind == PcDescriptors::kFuncCall) ||
|
|
(kind == PcDescriptors::kReturn)) {
|
|
bpt = new CodeBreakpoint(target_function, i);
|
|
RegisterCodeBreakpoint(bpt);
|
|
bpt->Enable();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Debugger::SignalBpResolved(SourceBreakpoint* bpt) {
|
|
if (event_handler_ != NULL) {
|
|
DebuggerEvent event;
|
|
event.type = kBreakpointResolved;
|
|
event.breakpoint = bpt;
|
|
(*event_handler_)(&event);
|
|
}
|
|
}
|
|
|
|
|
|
DebuggerStackTrace* Debugger::CollectStackTrace() {
|
|
DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
|
|
Context& ctx = Context::Handle(Isolate::Current()->top_context());
|
|
DartFrameIterator iterator;
|
|
StackFrame* frame = iterator.NextFrame();
|
|
while (frame != NULL) {
|
|
ASSERT(frame->IsValid());
|
|
ASSERT(frame->IsDartFrame());
|
|
ActivationFrame* activation =
|
|
new ActivationFrame(frame->pc(), frame->fp(), frame->sp(), ctx);
|
|
ctx = activation->CallerContext();
|
|
stack_trace->AddActivation(activation);
|
|
frame = iterator.NextFrame();
|
|
}
|
|
return stack_trace;
|
|
}
|
|
|
|
|
|
void Debugger::SetExceptionPauseInfo(Dart_ExceptionPauseInfo pause_info) {
|
|
ASSERT((pause_info == kNoPauseOnExceptions) ||
|
|
(pause_info == kPauseOnUnhandledExceptions) ||
|
|
(pause_info == kPauseOnAllExceptions));
|
|
exc_pause_info_ = pause_info;
|
|
}
|
|
|
|
|
|
Dart_ExceptionPauseInfo Debugger::GetExceptionPauseInfo() {
|
|
return (Dart_ExceptionPauseInfo)exc_pause_info_;
|
|
}
|
|
|
|
|
|
bool Debugger::ShouldPauseOnException(DebuggerStackTrace* stack_trace,
|
|
const Instance& exc) {
|
|
if (exc_pause_info_ == kNoPauseOnExceptions) {
|
|
return false;
|
|
}
|
|
if (exc_pause_info_ == kPauseOnAllExceptions) {
|
|
return true;
|
|
}
|
|
ASSERT(exc_pause_info_ == kPauseOnUnhandledExceptions);
|
|
ActivationFrame* handler_frame = stack_trace->GetHandlerFrame(exc);
|
|
if (handler_frame == NULL) {
|
|
// Did not find an exception handler that catches this exception.
|
|
// Note that this check is not precise, since we can't check
|
|
// uninstantiated types, i.e. types containing type parameters.
|
|
// Thus, we may report an exception as unhandled when in fact
|
|
// it will be caught once we unwind the stack.
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
void Debugger::SignalExceptionThrown(const Instance& exc) {
|
|
// We ignore this exception event when the VM is executing code invoked
|
|
// by the debugger to evaluate variables values, when we see a nested
|
|
// breakpoint or exception event, or if the debugger is not
|
|
// interested in exception events.
|
|
if (ignore_breakpoints_ ||
|
|
(stack_trace_ != NULL) ||
|
|
(event_handler_ == NULL) ||
|
|
(exc_pause_info_ == kNoPauseOnExceptions)) {
|
|
return;
|
|
}
|
|
DebuggerStackTrace* stack_trace = CollectStackTrace();
|
|
if (!ShouldPauseOnException(stack_trace, exc)) {
|
|
return;
|
|
}
|
|
// No single-stepping possible after this pause event.
|
|
last_bpt_line_ = -1;
|
|
ASSERT(stack_trace_ == NULL);
|
|
stack_trace_ = stack_trace;
|
|
ASSERT(obj_cache_ == NULL);
|
|
obj_cache_ = new RemoteObjectCache(64);
|
|
DebuggerEvent event;
|
|
event.type = kExceptionThrown;
|
|
event.exception = &exc;
|
|
ASSERT(event_handler_ != NULL);
|
|
(*event_handler_)(&event);
|
|
stack_trace_ = NULL;
|
|
obj_cache_ = NULL; // Remote object cache is zone allocated.
|
|
}
|
|
|
|
|
|
CodeBreakpoint* Debugger::MakeCodeBreakpoint(const Function& func,
|
|
intptr_t first_token_pos,
|
|
intptr_t last_token_pos) {
|
|
ASSERT(func.HasCode());
|
|
ASSERT(!func.HasOptimizedCode());
|
|
Code& code = Code::Handle(func.unoptimized_code());
|
|
ASSERT(!code.IsNull());
|
|
PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
|
|
// We attempt to find the PC descriptor that is closest to the
|
|
// beginning of the token range, in terms of native code address. If we
|
|
// don't find a PC descriptor within the given range, we pick the
|
|
// nearest one to the beginning of the range, in terms of token position.
|
|
intptr_t best_fit_index = -1;
|
|
intptr_t best_fit = INT_MAX;
|
|
uword lowest_pc = kUwordMax;
|
|
intptr_t lowest_pc_index = -1;
|
|
for (int i = 0; i < desc.Length(); i++) {
|
|
intptr_t desc_token_pos = desc.TokenPos(i);
|
|
if (desc_token_pos < first_token_pos) {
|
|
continue;
|
|
}
|
|
PcDescriptors::Kind kind = desc.DescriptorKind(i);
|
|
if ((kind == PcDescriptors::kIcCall) ||
|
|
(kind == PcDescriptors::kFuncCall) ||
|
|
(kind == PcDescriptors::kReturn)) {
|
|
if ((desc_token_pos - first_token_pos) < best_fit) {
|
|
best_fit = desc_token_pos - first_token_pos;
|
|
ASSERT(best_fit >= 0);
|
|
best_fit_index = i;
|
|
}
|
|
if ((first_token_pos <= desc_token_pos) &&
|
|
(desc_token_pos <= last_token_pos) &&
|
|
(desc.PC(i) < lowest_pc)) {
|
|
lowest_pc = desc.PC(i);
|
|
lowest_pc_index = i;
|
|
}
|
|
}
|
|
}
|
|
if (lowest_pc_index >= 0) {
|
|
// We found the the pc descriptor within the given token range that
|
|
// has the lowest execution address. This is the first possible
|
|
// breakpoint on the line. We use this instead of the nearest
|
|
// PC descriptor measured in token index distance.
|
|
best_fit_index = lowest_pc_index;
|
|
}
|
|
if (best_fit_index >= 0) {
|
|
CodeBreakpoint* bpt = GetCodeBreakpoint(desc.PC(best_fit_index));
|
|
// We should only ever have one code breakpoint at the same address.
|
|
if (bpt != NULL) {
|
|
return bpt;
|
|
}
|
|
|
|
bpt = new CodeBreakpoint(func, best_fit_index);
|
|
if (FLAG_verbose_debug) {
|
|
OS::Print("Setting breakpoint in function '%s' "
|
|
"(%s:%"Pd") (Token %"Pd") (PC %#"Px")\n",
|
|
String::Handle(func.name()).ToCString(),
|
|
String::Handle(bpt->SourceUrl()).ToCString(),
|
|
bpt->LineNumber(),
|
|
bpt->token_pos(),
|
|
bpt->pc());
|
|
}
|
|
RegisterCodeBreakpoint(bpt);
|
|
return bpt;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
SourceBreakpoint* Debugger::SetBreakpoint(const Function& target_function,
|
|
intptr_t first_token_pos,
|
|
intptr_t last_token_pos) {
|
|
if ((last_token_pos < target_function.token_pos()) ||
|
|
(target_function.end_token_pos() < first_token_pos)) {
|
|
// The given token position is not within the target function.
|
|
return NULL;
|
|
}
|
|
DeoptimizeWorld();
|
|
ASSERT(!target_function.HasOptimizedCode());
|
|
|
|
CodeBreakpoint* cbpt = NULL;
|
|
SourceBreakpoint* source_bpt = NULL;
|
|
if (target_function.HasCode()) {
|
|
cbpt = MakeCodeBreakpoint(target_function, first_token_pos, last_token_pos);
|
|
if (cbpt != NULL) {
|
|
if (cbpt->src_bpt() != NULL) {
|
|
// There is already a source breakpoint for the location.
|
|
ASSERT(cbpt->src_bpt() ==
|
|
GetSourceBreakpoint(target_function, cbpt->token_pos()));
|
|
return cbpt->src_bpt();
|
|
}
|
|
// No source breakpoint exists yet that is associated with the code
|
|
// breakpoint we found. (This is an internal breakpoint.) Adjust
|
|
// the breakpoint location to the actual position where breakpoint
|
|
// got set.
|
|
first_token_pos = cbpt->token_pos();
|
|
}
|
|
} else {
|
|
source_bpt = GetSourceBreakpoint(target_function, first_token_pos);
|
|
if (source_bpt != NULL) {
|
|
// A source breakpoint for this uncompiled location already
|
|
// exists.
|
|
return source_bpt;
|
|
}
|
|
}
|
|
source_bpt = new SourceBreakpoint(nextId(), target_function, first_token_pos);
|
|
RegisterSourceBreakpoint(source_bpt);
|
|
if (FLAG_verbose_debug && !target_function.HasCode()) {
|
|
OS::Print("Registering breakpoint for "
|
|
"uncompiled function '%s' at line %"Pd"\n",
|
|
target_function.ToFullyQualifiedCString(),
|
|
source_bpt->LineNumber());
|
|
}
|
|
|
|
if (cbpt != NULL) {
|
|
ASSERT(cbpt->src_bpt() == NULL);
|
|
cbpt->set_src_bpt(source_bpt);
|
|
SignalBpResolved(source_bpt);
|
|
} else {
|
|
if (FLAG_verbose_debug) {
|
|
OS::Print("Failed to set breakpoint at '%s' line %"Pd"\n",
|
|
String::Handle(source_bpt->SourceUrl()).ToCString(),
|
|
source_bpt->LineNumber());
|
|
}
|
|
}
|
|
|
|
if (target_function.HasImplicitClosureFunction()) {
|
|
// There is a closurized version of this function. If the closure
|
|
// is already compiled, we need to set a code breakpoint in its
|
|
// code.
|
|
const Function& closure =
|
|
Function::Handle(target_function.ImplicitClosureFunction());
|
|
if (closure.HasCode()) {
|
|
ASSERT(!closure.HasOptimizedCode());
|
|
CodeBreakpoint* closure_bpt =
|
|
MakeCodeBreakpoint(closure, first_token_pos, last_token_pos);
|
|
if ((closure_bpt != NULL) && (closure_bpt->src_bpt() == NULL)) {
|
|
closure_bpt->set_src_bpt(source_bpt);
|
|
}
|
|
}
|
|
}
|
|
source_bpt->Enable();
|
|
return source_bpt;
|
|
}
|
|
|
|
|
|
// Synchronize the enabled/disabled state of all code breakpoints
|
|
// associated with the source breakpoint bpt.
|
|
void Debugger::SyncBreakpoint(SourceBreakpoint* bpt) {
|
|
CodeBreakpoint* cbpt = code_breakpoints_;
|
|
while (cbpt != NULL) {
|
|
if (bpt == cbpt->src_bpt()) {
|
|
if (bpt->IsEnabled()) {
|
|
cbpt->Enable();
|
|
} else {
|
|
cbpt->Disable();
|
|
}
|
|
}
|
|
cbpt = cbpt->next();
|
|
}
|
|
}
|
|
|
|
|
|
void Debugger::OneTimeBreakAtEntry(const Function& target_function) {
|
|
InstrumentForStepping(target_function);
|
|
}
|
|
|
|
|
|
SourceBreakpoint* Debugger::SetBreakpointAtEntry(
|
|
const Function& target_function) {
|
|
ASSERT(!target_function.IsNull());
|
|
return SetBreakpoint(target_function,
|
|
target_function.token_pos(),
|
|
target_function.end_token_pos());
|
|
}
|
|
|
|
|
|
SourceBreakpoint* Debugger::SetBreakpointAtLine(const String& script_url,
|
|
intptr_t line_number) {
|
|
Library& lib = Library::Handle();
|
|
Script& script = Script::Handle();
|
|
const GrowableObjectArray& libs =
|
|
GrowableObjectArray::Handle(isolate_->object_store()->libraries());
|
|
for (int i = 0; i < libs.Length(); i++) {
|
|
lib ^= libs.At(i);
|
|
script = lib.LookupScript(script_url);
|
|
if (!script.IsNull()) {
|
|
break;
|
|
}
|
|
}
|
|
if (script.IsNull()) {
|
|
if (FLAG_verbose_debug) {
|
|
OS::Print("Failed to find script with url '%s'\n",
|
|
script_url.ToCString());
|
|
}
|
|
return NULL;
|
|
}
|
|
intptr_t first_token_idx, last_token_idx;
|
|
script.TokenRangeAtLine(line_number, &first_token_idx, &last_token_idx);
|
|
if (first_token_idx < 0) {
|
|
// Script does not contain the given line number.
|
|
if (FLAG_verbose_debug) {
|
|
OS::Print("Script '%s' does not contain line number %"Pd"\n",
|
|
script_url.ToCString(), line_number);
|
|
}
|
|
return NULL;
|
|
}
|
|
const Function& func =
|
|
Function::Handle(lib.LookupFunctionInScript(script, first_token_idx));
|
|
if (func.IsNull()) {
|
|
if (FLAG_verbose_debug) {
|
|
OS::Print("No executable code at line %"Pd" in '%s'\n",
|
|
line_number, script_url.ToCString());
|
|
}
|
|
return NULL;
|
|
}
|
|
if (last_token_idx < 0) {
|
|
// The token at first_token_index is past the requested source line.
|
|
// Set the breakpoint at the closest position after that line.
|
|
last_token_idx = func.end_token_pos();
|
|
}
|
|
return SetBreakpoint(func, first_token_idx, last_token_idx);
|
|
}
|
|
|
|
|
|
intptr_t Debugger::CacheObject(const Object& obj) {
|
|
ASSERT(obj_cache_ != NULL);
|
|
return obj_cache_->AddObject(obj);
|
|
}
|
|
|
|
|
|
bool Debugger::IsValidObjectId(intptr_t obj_id) {
|
|
ASSERT(obj_cache_ != NULL);
|
|
return obj_cache_->IsValidId(obj_id);
|
|
}
|
|
|
|
|
|
RawObject* Debugger::GetCachedObject(intptr_t obj_id) {
|
|
ASSERT(obj_cache_ != NULL);
|
|
return obj_cache_->GetObj(obj_id);
|
|
}
|
|
|
|
// TODO(hausner): Merge some of this functionality with the code in
|
|
// dart_api_impl.cc.
|
|
RawObject* Debugger::GetInstanceField(const Class& cls,
|
|
const String& field_name,
|
|
const Instance& object) {
|
|
const Function& getter_func =
|
|
Function::Handle(cls.LookupGetterFunction(field_name));
|
|
ASSERT(!getter_func.IsNull());
|
|
|
|
Object& result = Object::Handle();
|
|
LongJump* base = isolate_->long_jump_base();
|
|
LongJump jump;
|
|
isolate_->set_long_jump_base(&jump);
|
|
bool saved_ignore_flag = ignore_breakpoints_;
|
|
ignore_breakpoints_ = true;
|
|
if (setjmp(*jump.Set()) == 0) {
|
|
const Array& args = Array::Handle(Array::New(1));
|
|
args.SetAt(0, object);
|
|
result = DartEntry::InvokeDynamic(getter_func, args);
|
|
} else {
|
|
result = isolate_->object_store()->sticky_error();
|
|
}
|
|
ignore_breakpoints_ = saved_ignore_flag;
|
|
isolate_->set_long_jump_base(base);
|
|
return result.raw();
|
|
}
|
|
|
|
|
|
RawObject* Debugger::GetStaticField(const Class& cls,
|
|
const String& field_name) {
|
|
const Field& fld = Field::Handle(cls.LookupStaticField(field_name));
|
|
if (!fld.IsNull()) {
|
|
// Return the value in the field if it has been initialized already.
|
|
const Instance& value = Instance::Handle(fld.value());
|
|
ASSERT(value.raw() != Object::transition_sentinel().raw());
|
|
if (value.raw() != Object::sentinel().raw()) {
|
|
return value.raw();
|
|
}
|
|
}
|
|
// There is no field or the field has not been initialized yet.
|
|
// We must have a getter. Run the getter.
|
|
const Function& getter_func =
|
|
Function::Handle(cls.LookupGetterFunction(field_name));
|
|
ASSERT(!getter_func.IsNull());
|
|
if (getter_func.IsNull()) {
|
|
return Object::null();
|
|
}
|
|
|
|
Object& result = Object::Handle();
|
|
LongJump* base = isolate_->long_jump_base();
|
|
LongJump jump;
|
|
isolate_->set_long_jump_base(&jump);
|
|
bool saved_ignore_flag = ignore_breakpoints_;
|
|
ignore_breakpoints_ = true;
|
|
if (setjmp(*jump.Set()) == 0) {
|
|
result = DartEntry::InvokeStatic(getter_func, Object::empty_array());
|
|
} else {
|
|
result = isolate_->object_store()->sticky_error();
|
|
}
|
|
ignore_breakpoints_ = saved_ignore_flag;
|
|
isolate_->set_long_jump_base(base);
|
|
return result.raw();
|
|
}
|
|
|
|
|
|
RawArray* Debugger::GetInstanceFields(const Instance& obj) {
|
|
Class& cls = Class::Handle(obj.clazz());
|
|
Array& fields = Array::Handle();
|
|
Field& field = Field::Handle();
|
|
const GrowableObjectArray& field_list =
|
|
GrowableObjectArray::Handle(GrowableObjectArray::New(8));
|
|
String& field_name = String::Handle();
|
|
Object& field_value = Object::Handle();
|
|
// Iterate over fields in class hierarchy to count all instance fields.
|
|
while (!cls.IsNull()) {
|
|
fields = cls.fields();
|
|
for (int i = 0; i < fields.Length(); i++) {
|
|
field ^= fields.At(i);
|
|
if (!field.is_static()) {
|
|
field_name = field.name();
|
|
field_list.Add(field_name);
|
|
field_value = GetInstanceField(cls, field_name, obj);
|
|
field_list.Add(field_value);
|
|
}
|
|
}
|
|
cls = cls.SuperClass();
|
|
}
|
|
return Array::MakeArray(field_list);
|
|
}
|
|
|
|
|
|
RawArray* Debugger::GetStaticFields(const Class& cls) {
|
|
const GrowableObjectArray& field_list =
|
|
GrowableObjectArray::Handle(GrowableObjectArray::New(8));
|
|
Array& fields = Array::Handle(cls.fields());
|
|
Field& field = Field::Handle();
|
|
String& field_name = String::Handle();
|
|
Object& field_value = Object::Handle();
|
|
for (int i = 0; i < fields.Length(); i++) {
|
|
field ^= fields.At(i);
|
|
if (field.is_static()) {
|
|
field_name = field.name();
|
|
field_value = GetStaticField(cls, field_name);
|
|
field_list.Add(field_name);
|
|
field_list.Add(field_value);
|
|
}
|
|
}
|
|
return Array::MakeArray(field_list);
|
|
}
|
|
|
|
|
|
void Debugger::CollectLibraryFields(const GrowableObjectArray& field_list,
|
|
const Library& lib,
|
|
const String& prefix,
|
|
bool include_private_fields) {
|
|
DictionaryIterator it(lib);
|
|
Object& entry = Object::Handle(isolate_);
|
|
Field& field = Field::Handle(isolate_);
|
|
Class& cls = Class::Handle(isolate_);
|
|
String& field_name = String::Handle(isolate_);
|
|
Object& field_value = Object::Handle(isolate_);
|
|
while (it.HasNext()) {
|
|
entry = it.GetNext();
|
|
if (entry.IsField()) {
|
|
field ^= entry.raw();
|
|
cls = field.owner();
|
|
ASSERT(field.is_static());
|
|
field_name = field.name();
|
|
if ((field_name.CharAt(0) == '_') && !include_private_fields) {
|
|
// Skip library-private field.
|
|
continue;
|
|
}
|
|
field_value = GetStaticField(cls, field_name);
|
|
if (!prefix.IsNull()) {
|
|
field_name = String::Concat(prefix, field_name);
|
|
}
|
|
field_list.Add(field_name);
|
|
field_list.Add(field_value);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
RawArray* Debugger::GetLibraryFields(const Library& lib) {
|
|
const GrowableObjectArray& field_list =
|
|
GrowableObjectArray::Handle(GrowableObjectArray::New(8));
|
|
CollectLibraryFields(field_list, lib, String::Handle(isolate_), true);
|
|
return Array::MakeArray(field_list);
|
|
}
|
|
|
|
|
|
RawArray* Debugger::GetGlobalFields(const Library& lib) {
|
|
const GrowableObjectArray& field_list =
|
|
GrowableObjectArray::Handle(GrowableObjectArray::New(8));
|
|
String& prefix_name = String::Handle(isolate_);
|
|
CollectLibraryFields(field_list, lib, prefix_name, true);
|
|
Library& imported = Library::Handle(isolate_);
|
|
intptr_t num_imports = lib.num_imports();
|
|
for (int i = 0; i < num_imports; i++) {
|
|
imported = lib.ImportLibraryAt(i);
|
|
ASSERT(!imported.IsNull());
|
|
CollectLibraryFields(field_list, imported, prefix_name, false);
|
|
}
|
|
LibraryPrefix& prefix = LibraryPrefix::Handle(isolate_);
|
|
LibraryPrefixIterator it(lib);
|
|
while (it.HasNext()) {
|
|
prefix = it.GetNext();
|
|
prefix_name = prefix.name();
|
|
ASSERT(!prefix_name.IsNull());
|
|
prefix_name = String::Concat(prefix_name, Symbols::Dot());
|
|
for (int i = 0; i < prefix.num_imports(); i++) {
|
|
imported = prefix.GetLibrary(i);
|
|
CollectLibraryFields(field_list, imported, prefix_name, false);
|
|
}
|
|
}
|
|
return Array::MakeArray(field_list);
|
|
}
|
|
|
|
|
|
void Debugger::VisitObjectPointers(ObjectPointerVisitor* visitor) {
|
|
ASSERT(visitor != NULL);
|
|
SourceBreakpoint* bpt = src_breakpoints_;
|
|
while (bpt != NULL) {
|
|
bpt->VisitObjectPointers(visitor);
|
|
bpt = bpt->next();
|
|
}
|
|
CodeBreakpoint* cbpt = code_breakpoints_;
|
|
while (cbpt != NULL) {
|
|
cbpt->VisitObjectPointers(visitor);
|
|
cbpt = cbpt->next();
|
|
}
|
|
}
|
|
|
|
|
|
void Debugger::SetBreakpointHandler(BreakpointHandler* handler) {
|
|
if (bp_handler_ != NULL) {
|
|
bp_handler_ = handler;
|
|
}
|
|
}
|
|
|
|
|
|
void Debugger::SetEventHandler(EventHandler* handler) {
|
|
event_handler_ = handler;
|
|
}
|
|
|
|
|
|
bool Debugger::IsDebuggable(const Function& func) {
|
|
RawFunction::Kind fkind = func.kind();
|
|
if ((fkind == RawFunction::kImplicitGetter) ||
|
|
(fkind == RawFunction::kImplicitSetter) ||
|
|
(fkind == RawFunction::kConstImplicitGetter) ||
|
|
(fkind == RawFunction::kMethodExtractor)) {
|
|
return false;
|
|
}
|
|
const Class& cls = Class::Handle(func.Owner());
|
|
const Library& lib = Library::Handle(cls.library());
|
|
return lib.IsDebuggable();
|
|
}
|
|
|
|
|
|
void Debugger::SignalBpReached() {
|
|
// We ignore this breakpoint when the VM is executing code invoked
|
|
// by the debugger to evaluate variables values, or when we see a nested
|
|
// breakpoint or exception event.
|
|
if (ignore_breakpoints_ || (stack_trace_ != NULL)) {
|
|
return;
|
|
}
|
|
DebuggerStackTrace* stack_trace = CollectStackTrace();
|
|
ASSERT(stack_trace->Length() > 0);
|
|
ActivationFrame* top_frame = stack_trace->ActivationFrameAt(0);
|
|
ASSERT(top_frame != NULL);
|
|
CodeBreakpoint* bpt = GetCodeBreakpoint(top_frame->pc());
|
|
ASSERT(bpt != NULL);
|
|
if (FLAG_verbose_debug) {
|
|
OS::Print(">>> hit %s breakpoint at %s:%"Pd" "
|
|
"(token %"Pd") (address %#"Px")\n",
|
|
bpt->IsInternal() ? "internal" : "user",
|
|
String::Handle(bpt->SourceUrl()).ToCString(),
|
|
bpt->LineNumber(),
|
|
bpt->token_pos(),
|
|
top_frame->pc());
|
|
}
|
|
|
|
if (!bpt->IsInternal()) {
|
|
// This is a user-defined breakpoint so we call the breakpoint
|
|
// callback even if it is on the same line as the previous breakpoint.
|
|
last_bpt_line_ = -1;
|
|
}
|
|
|
|
bool notify_frontend =
|
|
(last_bpt_line_ < 0) || (last_bpt_line_ != bpt->LineNumber());
|
|
|
|
if (notify_frontend) {
|
|
resume_action_ = kContinue;
|
|
if (bp_handler_ != NULL) {
|
|
SourceBreakpoint* src_bpt = bpt->src_bpt();
|
|
ASSERT(stack_trace_ == NULL);
|
|
ASSERT(obj_cache_ == NULL);
|
|
obj_cache_ = new RemoteObjectCache(64);
|
|
stack_trace_ = stack_trace;
|
|
(*bp_handler_)(GetIsolateId(), src_bpt, stack_trace);
|
|
stack_trace_ = NULL;
|
|
obj_cache_ = NULL; // Remote object cache is zone allocated.
|
|
last_bpt_line_ = bpt->LineNumber();
|
|
}
|
|
}
|
|
|
|
Function& currently_instrumented_func = Function::Handle();
|
|
if (bpt->IsInternal()) {
|
|
currently_instrumented_func = bpt->function();
|
|
}
|
|
Function& func_to_instrument = Function::Handle();
|
|
if (resume_action_ == kContinue) {
|
|
// Nothing to do here, any potential instrumentation will be removed
|
|
// below.
|
|
} else if (resume_action_ == kStepOver) {
|
|
func_to_instrument = bpt->function();
|
|
if (bpt->breakpoint_kind_ == PcDescriptors::kReturn) {
|
|
// If we are at the function return, do a StepOut action.
|
|
if (stack_trace->Length() > 1) {
|
|
ActivationFrame* caller_frame = stack_trace->ActivationFrameAt(1);
|
|
func_to_instrument = caller_frame->DartFunction().raw();
|
|
}
|
|
}
|
|
} else if (resume_action_ == kStepInto) {
|
|
// If the call target is not debuggable, we treat StepInto like
|
|
// a StepOver, that is we instrument the current function.
|
|
if (bpt->breakpoint_kind_ == PcDescriptors::kIcCall) {
|
|
func_to_instrument = bpt->function();
|
|
ICData& ic_data = ICData::Handle();
|
|
Array& descriptor = Array::Handle();
|
|
CodePatcher::GetInstanceCallAt(bpt->pc_, &ic_data, &descriptor);
|
|
ArgumentsDescriptor arg_descriptor(descriptor);
|
|
ActivationFrame* top_frame = stack_trace->ActivationFrameAt(0);
|
|
intptr_t num_args = arg_descriptor.Count();
|
|
Instance& receiver =
|
|
Instance::Handle(top_frame->GetInstanceCallReceiver(num_args));
|
|
Code& code =
|
|
Code::Handle(ResolveCompileInstanceCallTarget(receiver,
|
|
ic_data,
|
|
descriptor));
|
|
if (!code.IsNull()) {
|
|
Function& callee = Function::Handle(code.function());
|
|
if (IsDebuggable(callee)) {
|
|
func_to_instrument = callee.raw();
|
|
}
|
|
}
|
|
} else if (bpt->breakpoint_kind_ == PcDescriptors::kFuncCall) {
|
|
func_to_instrument = bpt->function();
|
|
const Code& code = Code::Handle(func_to_instrument.CurrentCode());
|
|
const Function& callee =
|
|
Function::Handle(code.GetStaticCallTargetFunctionAt(bpt->pc_));
|
|
ASSERT(!callee.IsNull());
|
|
if (IsDebuggable(callee)) {
|
|
func_to_instrument = callee.raw();
|
|
}
|
|
} else {
|
|
ASSERT(bpt->breakpoint_kind_ == PcDescriptors::kReturn);
|
|
// Treat like stepping out to caller.
|
|
if (stack_trace->Length() > 1) {
|
|
ActivationFrame* caller_frame = stack_trace->ActivationFrameAt(1);
|
|
func_to_instrument = caller_frame->DartFunction().raw();
|
|
}
|
|
}
|
|
} else {
|
|
ASSERT(resume_action_ == kStepOut);
|
|
// Set stepping breakpoints in the caller.
|
|
if (stack_trace->Length() > 1) {
|
|
ActivationFrame* caller_frame = stack_trace->ActivationFrameAt(1);
|
|
func_to_instrument = caller_frame->DartFunction().raw();
|
|
}
|
|
}
|
|
|
|
if (func_to_instrument.IsNull() ||
|
|
(func_to_instrument.raw() != currently_instrumented_func.raw())) {
|
|
last_bpt_line_ = -1;
|
|
RemoveInternalBreakpoints(); // *bpt is now invalid.
|
|
if (!func_to_instrument.IsNull()) {
|
|
InstrumentForStepping(func_to_instrument);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Debugger::Initialize(Isolate* isolate) {
|
|
if (initialized_) {
|
|
return;
|
|
}
|
|
isolate_ = isolate;
|
|
// Create a port here, we don't expect to receive any messages on this port.
|
|
// This port will be used as a unique ID to represet the isolate in the
|
|
// debugger wire protocol messages.
|
|
// NOTE: SetLive is never called on this port.
|
|
isolate_id_ = PortMap::CreatePort(isolate->message_handler());
|
|
initialized_ = true;
|
|
|
|
// Signal isolate creation event.
|
|
SignalIsolateEvent(Debugger::kIsolateCreated);
|
|
}
|
|
|
|
|
|
void Debugger::NotifyCompilation(const Function& func) {
|
|
if (src_breakpoints_ == NULL) {
|
|
// Return with minimal overhead if there are no breakpoints.
|
|
return;
|
|
}
|
|
Function& lookup_function = Function::Handle(func.raw());
|
|
if (func.IsImplicitClosureFunction()) {
|
|
// If the newly compiled function is a an implicit closure (a closure that
|
|
// was formed by assigning a static or instance method to a function
|
|
// object), we need to use the closure's parent function to see whether
|
|
// there are any breakpoints. The parent function is the actual method on
|
|
// which the user sets breakpoints.
|
|
lookup_function = func.parent_function();
|
|
ASSERT(!lookup_function.IsNull());
|
|
}
|
|
SourceBreakpoint* bpt = src_breakpoints_;
|
|
while (bpt != NULL) {
|
|
if (lookup_function.raw() == bpt->function()) {
|
|
// Check if the breakpoint is inside a closure or local function
|
|
// within the newly compiled function.
|
|
Class& owner = Class::Handle(lookup_function.Owner());
|
|
Function& closure =
|
|
Function::Handle(owner.LookupClosureFunction(bpt->token_pos()));
|
|
if (!closure.IsNull() && (closure.raw() != lookup_function.raw())) {
|
|
if (FLAG_verbose_debug) {
|
|
OS::Print("Resetting pending breakpoint to function %s\n",
|
|
closure.ToFullyQualifiedCString());
|
|
}
|
|
bpt->set_function(closure);
|
|
} else {
|
|
if (FLAG_verbose_debug) {
|
|
OS::Print("Enable pending breakpoint for function '%s'\n",
|
|
String::Handle(lookup_function.name()).ToCString());
|
|
}
|
|
// Set breakpoint in newly compiled code of function func.
|
|
CodeBreakpoint* cbpt =
|
|
MakeCodeBreakpoint(func, bpt->token_pos(), func.end_token_pos());
|
|
if (cbpt != NULL) {
|
|
cbpt->set_src_bpt(bpt);
|
|
SignalBpResolved(bpt);
|
|
}
|
|
}
|
|
bpt->Enable(); // Enables the code breakpoint as well.
|
|
}
|
|
bpt = bpt->next();
|
|
}
|
|
}
|
|
|
|
|
|
CodeBreakpoint* Debugger::GetCodeBreakpoint(uword breakpoint_address) {
|
|
CodeBreakpoint* bpt = code_breakpoints_;
|
|
while (bpt != NULL) {
|
|
if (bpt->pc() == breakpoint_address) {
|
|
return bpt;
|
|
}
|
|
bpt = bpt->next();
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
// Remove and delete the source breakpoint bpt and its associated
|
|
// code breakpoints.
|
|
void Debugger::RemoveBreakpoint(intptr_t bp_id) {
|
|
ASSERT(src_breakpoints_ != NULL);
|
|
SourceBreakpoint* prev_bpt = NULL;
|
|
SourceBreakpoint* curr_bpt = src_breakpoints_;
|
|
while (curr_bpt != NULL) {
|
|
if (curr_bpt->id() == bp_id) {
|
|
if (prev_bpt == NULL) {
|
|
src_breakpoints_ = src_breakpoints_->next();
|
|
} else {
|
|
prev_bpt->set_next(curr_bpt->next());
|
|
}
|
|
// Remove references from code breakpoints to this source breakpoint,
|
|
// and disable the code breakpoints.
|
|
UnlinkCodeBreakpoints(curr_bpt);
|
|
delete curr_bpt;
|
|
return;
|
|
}
|
|
prev_bpt = curr_bpt;
|
|
curr_bpt = curr_bpt->next();
|
|
}
|
|
// bpt is not a registered breakpoint, nothing to do.
|
|
}
|
|
|
|
|
|
// Turn code breakpoints associated with the given source breakpoint into
|
|
// internal breakpoints. They will later be deleted when control
|
|
// returns from the user-defined breakpoint callback. Also, disable the
|
|
// breakpoint so it no longer fires if it should be hit before it gets
|
|
// deleted.
|
|
void Debugger::UnlinkCodeBreakpoints(SourceBreakpoint* src_bpt) {
|
|
ASSERT(src_bpt != NULL);
|
|
CodeBreakpoint* curr_bpt = code_breakpoints_;
|
|
while (curr_bpt != NULL) {
|
|
if (curr_bpt->src_bpt() == src_bpt) {
|
|
curr_bpt->Disable();
|
|
curr_bpt->set_src_bpt(NULL);
|
|
}
|
|
curr_bpt = curr_bpt->next();
|
|
}
|
|
}
|
|
|
|
|
|
// Remove and delete internal breakpoints, i.e. breakpoints that
|
|
// are not associated with a source breakpoint.
|
|
void Debugger::RemoveInternalBreakpoints() {
|
|
CodeBreakpoint* prev_bpt = NULL;
|
|
CodeBreakpoint* curr_bpt = code_breakpoints_;
|
|
while (curr_bpt != NULL) {
|
|
if (curr_bpt->src_bpt() == NULL) {
|
|
if (prev_bpt == NULL) {
|
|
code_breakpoints_ = code_breakpoints_->next();
|
|
} else {
|
|
prev_bpt->set_next(curr_bpt->next());
|
|
}
|
|
CodeBreakpoint* temp_bpt = curr_bpt;
|
|
curr_bpt = curr_bpt->next();
|
|
temp_bpt->Disable();
|
|
delete temp_bpt;
|
|
} else {
|
|
prev_bpt = curr_bpt;
|
|
curr_bpt = curr_bpt->next();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
SourceBreakpoint* Debugger::GetSourceBreakpoint(const Function& func,
|
|
intptr_t token_pos) {
|
|
SourceBreakpoint* bpt = src_breakpoints_;
|
|
while (bpt != NULL) {
|
|
if ((bpt->function() == func.raw()) &&
|
|
(bpt->token_pos() == token_pos)) {
|
|
return bpt;
|
|
}
|
|
bpt = bpt->next();
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
SourceBreakpoint* Debugger::GetBreakpointById(intptr_t id) {
|
|
SourceBreakpoint* bpt = src_breakpoints_;
|
|
while (bpt != NULL) {
|
|
if (bpt->id() == id) {
|
|
return bpt;
|
|
}
|
|
bpt = bpt->next();
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void Debugger::RegisterSourceBreakpoint(SourceBreakpoint* bpt) {
|
|
ASSERT(bpt->next() == NULL);
|
|
bpt->set_next(src_breakpoints_);
|
|
src_breakpoints_ = bpt;
|
|
}
|
|
|
|
|
|
void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
|
|
ASSERT(bpt->next() == NULL);
|
|
bpt->set_next(code_breakpoints_);
|
|
code_breakpoints_ = bpt;
|
|
}
|
|
|
|
} // namespace dart
|