Beginnings of a debugger wire protocol

runtime/bin/main.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 <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
 #include "include/dart_api.h"
 #include "include/dart_debugger_api.h"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
+#include "bin/dbg_connection.h"
 #include "bin/directory.h"
 #include "bin/eventhandler.h"
 #include "bin/extensions.h"
 #include "bin/file.h"
 #include "bin/platform.h"
 #include "bin/process.h"
 #include "platform/globals.h"
 
 // snapshot_buffer points to a snapshot if we link in a snapshot otherwise
 // it is initialized to NULL.
@@ skipping 15 matching lines @@
 // to be generated or not.
 static const char* generate_pprof_symbols_filename = NULL;
 
 
 // Global state that indicates whether there is a debug breakpoint.
 // This pointer points into an argv buffer and does not need to be
 // free'd.
 static const char* breakpoint_at = NULL;
 
 
+// Global state that indicates whether we should open a connection
+// and listen for a debugger to connect.
+static bool start_debugger = false;
+static const int DEFAULT_DEBUG_PORT = 5858;
+static int debug_port = 0;
+
+
 // Value of the --package-root flag.
 // (This pointer points into an argv buffer and does not need to be
 // free'd.)
 static const char* package_root = NULL;
 
 
 // Global flag that is used to indicate that we want to compile all the
 // dart functions and not run anything.
 static bool has_compile_all = false;
 
@@ skipping 18 matching lines @@
   package_root = arg;
 }
 
 
 static void ProcessCompileAllOption(const char* compile_all) {
   ASSERT(compile_all != NULL);
   has_compile_all = true;
 }
 
 
+static void ProcessDebugOption(const char* port) {
+  ASSERT(port != NULL);
+  debug_port = 0;
+  if (*port == '\0') {
+    debug_port = DEFAULT_DEBUG_PORT;
+  } else {
+    if ((*port == '=') || (*port == ':')) {
+      debug_port = atoi(port + 1);
+    }
+  }
+  if (debug_port == 0) {
+    fprintf(stderr, "unrecognized --debug option syntax. "
+                    "Use --debug[:<port number>]\n");

[siva, 2012/05/03 22:52:08]

see comment regarding having this option be
--debug=[<address>:]<port_number>

[hausner, 2012/05/03 23:52:00]

Done.

+    return;
+  }
+  breakpoint_at = "main";

[siva, 2012/05/03 22:52:08]

Maybe later on this should also be a command line option i.e people may chose to
have the VM wait on main for a debugger to attach or just run and allow for a
debugger to attach later and use the OOB mechanism to interrupt the running
program.

[hausner, 2012/05/03 23:52:00]

I agree. For now, I need this because I can't interrupt the running isolate.

On 2012/05/03 22:52:08, asiva wrote:

+  start_debugger = true;
+}
+
+
 static void ProcessPprofOption(const char* filename) {
   ASSERT(filename != NULL);
   generate_pprof_symbols_filename = filename;
 }
 
 
 static void ProcessImportMapOption(const char* map) {
   ASSERT(map != NULL);
   import_map_options->AddArgument(map);
 }
 
 
 static struct {
   const char* option_name;
   void (*process)(const char* option);
 } main_options[] = {
   { "--break_at=", ProcessBreakpointOption },
   { "--compile_all", ProcessCompileAllOption },
+  { "--debug", ProcessDebugOption },
   { "--generate_pprof_symbols=", ProcessPprofOption },
   { "--import_map=", ProcessImportMapOption },
   { "--package-root=", ProcessPackageRootOption },
   { NULL, NULL }
 };
 
 
 static bool ProcessMainOptions(const char* option) {
   int i = 0;
   const char* name = main_options[0].option_name;
@@ skipping 491 matching lines @@
   }
   // Set debug breakpoint if specified on the command line.
   if (breakpoint_at != NULL) {
     result = SetBreakpoint(breakpoint_at, library);
     if (Dart_IsError(result)) {
       return ErrorExit("Error setting breakpoint at '%s': %s\n",
           breakpoint_at,
           Dart_GetError(result));
     }
   }
+
+  // Start the debugger wire protocol handler if necessary.
+  if (start_debugger) {
+    ASSERT(debug_port != 0);
+    DebuggerConnectionHandler::StartHandler(debug_port);
+  }
+
   // Lookup and invoke the top level main function.
   result = Dart_Invoke(library, Dart_NewString("main"), 0, NULL);
   if (Dart_IsError(result)) {
     return ErrorExit("%s\n", Dart_GetError(result));
   }
   // Keep handling messages until the last active receive port is closed.
   result = Dart_RunLoop();
   if (Dart_IsError(result)) {
     return ErrorExit("%s\n", Dart_GetError(result));
   }
 
   Dart_ExitScope();
   // Dump symbol information for the profiler.
   DumpPprofSymbolInfo();
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
   // Terminate process exit-code handler.
   Process::TerminateExitCodeHandler();
 
   free(const_cast<char*>(original_script_name));
   free(const_cast<char*>(original_working_directory));
   free(const_cast<char*>(original_script_url));
 
   return 0;
 }