Very first steps for a debugger

runtime/vm/debugger.cc

+// 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.
+
+#include "vm/debugger.h"
+
+#include "vm/code_patcher.h"
+#include "vm/compiler.h"
+#include "vm/flags.h"
+#include "vm/globals.h"
+#include "vm/object.h"
+#include "vm/object_store.h"
+#include "vm/os.h"
+#include "vm/stub_code.h"
+#include "vm/visitor.h"
+
+
+namespace dart {
+
+DEFINE_FLAG(bool, debugger, false, "Debug breakpoint at main");
+DEFINE_FLAG(charp, bpt, NULL, "Debug breakpoint at <func>");

[siva, 2011/11/30 00:00:47]

I hope all these flags are just temporary stuff because the debug API should
drive this functionality.

[hausner, 2011/11/30 01:17:05]

Yes, only temporary.

+
+
+class Breakpoint {
+ public:
+  Breakpoint(const Function& func, int pc_desc_index, uword pc)

[srdjan, 2011/11/29 22:26:00]

intptr_t pc_dec_index

[hausner, 2011/11/30 01:17:05]

Done.

+      : function_(func.raw()),
+        pc_desc_index_(pc_desc_index),
+        pc_(pc),
+        next_(NULL) {
+  }
+
+  RawFunction* function() const { return function_; }
+  uword pc() const { return pc_; }
+
+  void set_next(Breakpoint* value) { next_ = value; }
+  Breakpoint* next() const { return this->next_; }
+
+  void VisitObjectPointers(ObjectPointerVisitor* visitor) {
+    visitor->VisitPointer(reinterpret_cast<RawObject**>(&function_));
+  }
+
+ private:

[srdjan, 2011/11/29 22:26:00]

DISALLOW_....

[hausner, 2011/11/30 01:17:05]

Done.

+  RawFunction* function_;
+  int pc_desc_index_;

[srdjan, 2011/11/29 22:26:00]

intptr_t

[hausner, 2011/11/30 01:17:05]

Done, but over the long run I would change this to a smaller integer. We don't
want to burn 4 or 8 bytes for a value that rarely is higher than 10 or 100.

(How do you create a memory hog? One byte at a time... :)

+  uword pc_;

[siva, 2011/11/30 00:00:47]

Don't you also need to store the original contents of the patched location so
that you can restore it when the breakpoint is deleted.

[hausner, 2011/11/30 01:17:05]

At this point I don't need to. To remove a BP I just have to restore the call to
the static or dynamic call stub. It may well make sense to save the overwritten
call target in the BP though. I'll do that when the need comes.

+  Breakpoint* next_;
+};
+
+
+Debugger::Debugger()
+    : initialized_(false),
+      breakpoints_(NULL) {
+}
+
+
+static RawFunction* ResolveLibraryFunction(const String& fname) {
+  Isolate* isolate = Isolate::Current();
+  const Library& root_lib =
+    Library::Handle(isolate->object_store()->root_library());

[srdjan, 2011/11/29 22:26:00]

4 spaces indent.

[hausner, 2011/11/30 01:17:05]

Done.

+  ASSERT(!root_lib.IsNull());
+  Function& function = Function::Handle();
+  const Object& object = Object::Handle(root_lib.LookupObject(fname));
+  if (!object.IsNull() && object.IsFunction()) {
+    function ^= object.raw();
+  }
+  return function.raw();
+}
+
+
+static RawFunction* ResolveFunction(const String& class_name,
+                                    const String& function_name) {
+  Isolate* isolate = Isolate::Current();
+  const Library& root_lib =
+      Library::Handle(isolate->object_store()->root_library());
+  const Class& cls = Class::Handle(root_lib.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();
+}
+
+
+
+void Debugger::SetBreakpoint(const String& class_name,
+                             const String& function_name) {
+  Function& func = Function::Handle();
+  if (class_name.IsNull() || (class_name.Length() == 0)) {
+    func = ResolveLibraryFunction(function_name);
+  } else {
+    func = ResolveFunction(class_name, function_name);
+  }
+  if (func.IsNull()) {
+    printf("could not find function '%s' in class '%s'\n",
+      function_name.ToCString(), class_name.ToCString());

[srdjan, 2011/11/29 22:26:00]

OS::Print

[hausner, 2011/11/30 01:17:05]

Done.

+    return;
+  }
+  if (!func.HasCode()) {
+    Compiler::CompileFunction(func);
+  }

[siva, 2011/11/30 00:00:47]

If the function already has code and it is running optimized code shouldn't we
deoptimize it here before proceeding.

Also once breakpoints are set we need a mechanism to disable the optimizing
compiler for this function until all breakpoints are removed.

[hausner, 2011/11/30 01:17:05]

Yes. For now I just assume the optimizing compiler is never invoked. I should
probably disable optimization implicitly when the --debug flag is present. 

+  Code& code = Code::Handle(func.code());
+  ASSERT(!code.IsNull());
+  PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
+  for (int i = 0; i < desc.Length(); i++) {
+    PcDescriptors::Kind kind = desc.DescriptorKind(i);
+    if (kind == PcDescriptors::kIcCall) {
+      printf("patching dynamic call at %p\n", desc.PC(i));

[srdjan, 2011/11/29 22:26:00]

ditto

Maybe add a tracing flag and hide the printing with it?

[hausner, 2011/11/30 01:17:05]

As mentioned above, all these prints will go away once the code matures. Is that
good enough?

+      CodePatcher::PatchInstanceCallAt(
+          desc.PC(i), StubCode::BreakpointDynamicEntryPoint());
+      AddBreakpoint(new Breakpoint(func, i, desc.PC(i)));

[siva, 2011/11/30 00:00:47]

you probably need a return here too, otherwise there will be multiple
breakpoints set.

[hausner, 2011/11/30 01:17:05]

Good catch. 

+    } else if (kind == PcDescriptors::kOther) {
+      if (CodePatcher::IsDartCall(desc.PC(i))) {
+        printf("patching static call at %p\n", desc.PC(i));
+        CodePatcher::PatchStaticCallAt(
+            desc.PC(i), StubCode::BreakpointStaticEntryPoint());
+        AddBreakpoint(new Breakpoint(func, i, desc.PC(i)));

[srdjan, 2011/11/29 22:26:00]

Who deletes breakpoints? Do we need a ~Debugger() to delete them?

[hausner, 2011/11/30 01:17:05]

Nobody yet. I think it's ok to leave this for future checkins.

+        return;
+      }

[siva, 2011/11/30 00:00:47]

Why don't we want to set breakpoints on locations which have calls to the
runtime or stubs?

In the current scenario we won't be able to set breakpoints on leaf dart
functions.

[hausner, 2011/11/30 01:17:05]

I had to leave some functionality for version 2 :)

Agree, your suggestion makes sense.

+    }
+  }
+  printf("no breakpoint location found in function '%s'\n",
+         function_name.ToCString());
+}
+
+
+void Debugger::VisitObjectPointers(ObjectPointerVisitor* visitor) {
+  ASSERT(visitor != NULL);
+  Breakpoint* bpt = this->breakpoints_;
+  while (bpt != NULL) {
+    bpt->VisitObjectPointers(visitor);
+    bpt = bpt->next();
+  }
+}
+
+
+void Debugger::Initialize(Isolate* isolate) {
+  if (initialized_) {
+    return;
+  }
+  initialized_ = true;
+  if (!FLAG_debugger) {
+    return;
+  }
+  if (FLAG_bpt == NULL) {
+    FLAG_bpt = "main";
+  }
+  String& cname = String::Handle();
+  String& fname = String::Handle();

[siva, 2011/11/30 00:00:47]

We would need a library name too over here, may not always be the root library.

[hausner, 2011/11/30 01:17:05]

Very true. To keep things simple for the beginning, I just assume the root
library implicitly.

+  char* dot = strchr(FLAG_bpt, '.');
+  if (dot == NULL) {
+    fname = String::New(FLAG_bpt);
+  } else {
+    fname = String::New(dot + 1);
+    cname = String::New(reinterpret_cast<const uint8_t*>(FLAG_bpt),
+                        dot - FLAG_bpt);
+  }
+
+  SetBreakpoint(cname, fname);
+}
+
+
+Breakpoint* Debugger::GetBreakpoint(uword breakpoint_address) {
+  Breakpoint* bpt = this->breakpoints_;
+  while (bpt != NULL) {
+    if (bpt->pc() == breakpoint_address) {
+      return bpt;
+    }
+    bpt = bpt->next();
+  }
+  return NULL;
+}
+
+
+void Debugger::AddBreakpoint(Breakpoint* bpt) {
+  ASSERT(bpt->next() == NULL);
+  bpt->set_next(this->breakpoints_);
+  this->breakpoints_ = bpt;
+}
+
+
+}  // namespace dart